Class BackgroundTaskUtil

java.lang.Object
com.liferay.portal.background.task.service.persistence.BackgroundTaskUtil

public class BackgroundTaskUtil extends Object
The persistence utility for the background task service. This utility wraps com.liferay.portal.background.task.service.persistence.impl.BackgroundTaskPersistenceImpl and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.

Caching information and settings can be found in portal.properties

See Also:
Generated:
  • Constructor Summary

    Constructors
    Constructor
    Description
     
  • Method Summary

    Modifier and Type
    Method
    Description
    static void
    cacheResult(BackgroundTask backgroundTask)
    Caches the background task in the entity cache if it is enabled.
    static void
    cacheResult(List<BackgroundTask> backgroundTasks)
    Caches the background tasks in the entity cache if it is enabled.
    static void
     
    static void
    clearCache(BackgroundTask backgroundTask)
     
    static int
    Returns the number of background tasks.
    static int
    countByCompanyId(long companyId)
    Returns the number of background tasks where companyId = ?.
    static int
    countByCompleted(boolean completed)
    Returns the number of background tasks where completed = ?.
    static int
    countByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames)
    Returns the number of background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.
    static int
    countByG_N_T(long groupId, String name, String taskExecutorClassName)
    Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
    static int
    countByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed)
    Returns the number of background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.
    static int
    countByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed)
    Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    static int
    countByG_S(long groupId, int status)
    Returns the number of background tasks where groupId = ? and status = ?.
    static int
    countByG_T(long[] groupIds, String[] taskExecutorClassNames)
    Returns the number of background tasks where groupId = any ? and taskExecutorClassName = any ?.
    static int
    countByG_T(long groupId, String taskExecutorClassName)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?.
    static int
    countByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed)
    Returns the number of background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.
    static int
    countByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
    static int
    countByG_T_S(long groupId, String[] taskExecutorClassNames, int status)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.
    static int
    countByG_T_S(long groupId, String taskExecutorClassName, int status)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
    static int
    countByGroupId(long groupId)
    Returns the number of background tasks where groupId = ?.
    static int
    countByStatus(int status)
    Returns the number of background tasks where status = ?.
    static int
    countByT_S(String[] taskExecutorClassNames, int status)
    Returns the number of background tasks where taskExecutorClassName = any ? and status = ?.
    static int
    countByT_S(String taskExecutorClassName, int status)
    Returns the number of background tasks where taskExecutorClassName = ? and status = ?.
    static long
    countWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
     
    create(long backgroundTaskId)
    Creates a new background task with the primary key.
    fetchByCompanyId_First(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where companyId = ?.
    fetchByCompanyId_Last(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where companyId = ?.
    fetchByCompleted_First(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where completed = ?.
    fetchByCompleted_Last(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where completed = ?.
    fetchByG_N_T_C_First(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    fetchByG_N_T_C_Last(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    fetchByG_N_T_First(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
    fetchByG_N_T_Last(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
    fetchByG_S_First(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and status = ?.
    fetchByG_S_Last(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and status = ?.
    fetchByG_T_C_First(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
    fetchByG_T_C_Last(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
    fetchByG_T_First(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
    fetchByG_T_Last(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
    fetchByG_T_S_First(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
    fetchByG_T_S_Last(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
    fetchByGroupId_First(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ?.
    fetchByGroupId_Last(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ?.
    fetchByPrimaryKey(long backgroundTaskId)
    Returns the background task with the primary key or returns null if it could not be found.
     
    fetchByStatus_First(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where status = ?.
    fetchByStatus_Last(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where status = ?.
    fetchByT_S_First(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?.
    fetchByT_S_Last(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?.
    Returns all the background tasks.
    findAll(int start, int end)
    Returns a range of all the background tasks.
    findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks.
    findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks.
    findByCompanyId(long companyId)
    Returns all the background tasks where companyId = ?.
    findByCompanyId(long companyId, int start, int end)
    Returns a range of all the background tasks where companyId = ?.
    findByCompanyId(long companyId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where companyId = ?.
    findByCompanyId(long companyId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where companyId = ?.
    findByCompanyId_First(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where companyId = ?.
    findByCompanyId_Last(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where companyId = ?.
    findByCompanyId_PrevAndNext(long backgroundTaskId, long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where companyId = ?.
    findByCompleted(boolean completed)
    Returns all the background tasks where completed = ?.
    findByCompleted(boolean completed, int start, int end)
    Returns a range of all the background tasks where completed = ?.
    findByCompleted(boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where completed = ?.
    findByCompleted(boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where completed = ?.
    findByCompleted_First(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where completed = ?.
    findByCompleted_Last(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where completed = ?.
    findByCompleted_PrevAndNext(long backgroundTaskId, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where completed = ?.
    findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames)
    Returns all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.
    findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames, int start, int end)
    Returns a range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.
    findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.
    findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?, optionally using the finder cache.
    findByG_N_T(long groupId, String name, String taskExecutorClassName)
    Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_N_T(long groupId, String name, String taskExecutorClassName, int start, int end)
    Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_N_T(long groupId, String name, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_N_T(long groupId, String name, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed)
    Returns all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed, int start, int end)
    Returns a range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?, optionally using the finder cache.
    findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed)
    Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed, int start, int end)
    Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C_First(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C_Last(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_C_PrevAndNext(long backgroundTaskId, long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
    findByG_N_T_First(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_N_T_Last(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_N_T_PrevAndNext(long backgroundTaskId, long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
    findByG_S(long groupId, int status)
    Returns all the background tasks where groupId = ? and status = ?.
    findByG_S(long groupId, int status, int start, int end)
    Returns a range of all the background tasks where groupId = ? and status = ?.
    findByG_S(long groupId, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and status = ?.
    findByG_S(long groupId, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and status = ?.
    findByG_S_First(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and status = ?.
    findByG_S_Last(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and status = ?.
    findByG_S_PrevAndNext(long backgroundTaskId, long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?.
    findByG_T(long[] groupIds, String[] taskExecutorClassNames)
    Returns all the background tasks where groupId = any ? and taskExecutorClassName = any ?.
    findByG_T(long[] groupIds, String[] taskExecutorClassNames, int start, int end)
    Returns a range of all the background tasks where groupId = any ? and taskExecutorClassName = any ?.
    findByG_T(long[] groupIds, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = any ? and taskExecutorClassName = any ?.
    findByG_T(long[] groupIds, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?, optionally using the finder cache.
    findByG_T(long groupId, String taskExecutorClassName)
    Returns all the background tasks where groupId = ? and taskExecutorClassName = ?.
    findByG_T(long groupId, String taskExecutorClassName, int start, int end)
    Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ?.
    findByG_T(long groupId, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?.
    findByG_T(long groupId, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?.
    findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed)
    Returns all the background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.
    findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed, int start, int end)
    Returns a range of all the background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.
    findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.
    findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?, optionally using the finder cache.
    findByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
    Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_C(long groupId, String taskExecutorClassName, boolean completed, int start, int end)
    Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_C(long groupId, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_C(long groupId, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_C_First(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_C_Last(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_C_PrevAndNext(long backgroundTaskId, long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
    findByG_T_First(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
    findByG_T_Last(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
    findByG_T_PrevAndNext(long backgroundTaskId, long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
    findByG_T_S(long groupId, String[] taskExecutorClassNames, int status)
    Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.
    findByG_T_S(long groupId, String[] taskExecutorClassNames, int status, int start, int end)
    Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.
    findByG_T_S(long groupId, String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.
    findByG_T_S(long groupId, String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?, optionally using the finder cache.
    findByG_T_S(long groupId, String taskExecutorClassName, int status)
    Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByG_T_S(long groupId, String taskExecutorClassName, int status, int start, int end)
    Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByG_T_S(long groupId, String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByG_T_S(long groupId, String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByG_T_S_First(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByG_T_S_Last(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByG_T_S_PrevAndNext(long backgroundTaskId, long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
    findByGroupId(long groupId)
    Returns all the background tasks where groupId = ?.
    findByGroupId(long groupId, int start, int end)
    Returns a range of all the background tasks where groupId = ?.
    findByGroupId(long groupId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where groupId = ?.
    findByGroupId(long groupId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where groupId = ?.
    findByGroupId_First(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where groupId = ?.
    findByGroupId_Last(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where groupId = ?.
    findByGroupId_PrevAndNext(long backgroundTaskId, long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where groupId = ?.
    findByPrimaryKey(long backgroundTaskId)
    Returns the background task with the primary key or throws a NoSuchBackgroundTaskException if it could not be found.
    findByStatus(int status)
    Returns all the background tasks where status = ?.
    findByStatus(int status, int start, int end)
    Returns a range of all the background tasks where status = ?.
    findByStatus(int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where status = ?.
    findByStatus(int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where status = ?.
    findByStatus_First(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where status = ?.
    findByStatus_Last(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where status = ?.
    findByStatus_PrevAndNext(long backgroundTaskId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where status = ?.
    findByT_S(String[] taskExecutorClassNames, int status)
    Returns all the background tasks where taskExecutorClassName = any ? and status = ?.
    findByT_S(String[] taskExecutorClassNames, int status, int start, int end)
    Returns a range of all the background tasks where taskExecutorClassName = any ? and status = ?.
    findByT_S(String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where taskExecutorClassName = any ? and status = ?.
    findByT_S(String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?, optionally using the finder cache.
    findByT_S(String taskExecutorClassName, int status)
    Returns all the background tasks where taskExecutorClassName = ? and status = ?.
    findByT_S(String taskExecutorClassName, int status, int start, int end)
    Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?.
    findByT_S(String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?.
    findByT_S(String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
    Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?.
    findByT_S_First(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?.
    findByT_S_Last(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?.
    findByT_S_PrevAndNext(long backgroundTaskId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
    Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?.
    findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
     
    findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, int end)
     
    findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
     
     
    remove(long backgroundTaskId)
    Removes the background task with the primary key from the database.
    static void
    Removes all the background tasks from the database.
    static void
    removeByCompanyId(long companyId)
    Removes all the background tasks where companyId = ? from the database.
    static void
    removeByCompleted(boolean completed)
    Removes all the background tasks where completed = ? from the database.
    static void
    removeByG_N_T(long groupId, String name, String taskExecutorClassName)
    Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database.
    static void
    removeByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed)
    Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ? from the database.
    static void
    removeByG_S(long groupId, int status)
    Removes all the background tasks where groupId = ? and status = ? from the database.
    static void
    removeByG_T(long groupId, String taskExecutorClassName)
    Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database.
    static void
    removeByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
    Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database.
    static void
    removeByG_T_S(long groupId, String taskExecutorClassName, int status)
    Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database.
    static void
    removeByGroupId(long groupId)
    Removes all the background tasks where groupId = ? from the database.
    static void
    removeByStatus(int status)
    Removes all the background tasks where status = ? from the database.
    static void
    removeByT_S(String taskExecutorClassName, int status)
    Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database.
    static void
     
    update(BackgroundTask backgroundTask)
     
    update(BackgroundTask backgroundTask, com.liferay.portal.kernel.service.ServiceContext serviceContext)
     
    updateImpl(BackgroundTask backgroundTask)
     

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Constructor Details

    • BackgroundTaskUtil

      public BackgroundTaskUtil()
  • Method Details

    • clearCache

      public static void clearCache()
      See Also:
      • BasePersistence.clearCache()
    • clearCache

      public static void clearCache(BackgroundTask backgroundTask)
      See Also:
      • BasePersistence.clearCache(com.liferay.portal.kernel.model.BaseModel)
    • countWithDynamicQuery

      public static long countWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
      See Also:
      • BasePersistence.countWithDynamicQuery(DynamicQuery)
    • fetchByPrimaryKeys

      public static Map<Serializable,BackgroundTask> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
      See Also:
      • BasePersistence.fetchByPrimaryKeys(Set)
    • findWithDynamicQuery

      public static List<BackgroundTask> findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
      See Also:
      • BasePersistence.findWithDynamicQuery(DynamicQuery)
    • findWithDynamicQuery

      public static List<BackgroundTask> findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, int end)
      See Also:
      • BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
    • findWithDynamicQuery

      public static List<BackgroundTask> findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      See Also:
      • BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
    • update

      public static BackgroundTask update(BackgroundTask backgroundTask)
      See Also:
      • BasePersistence.update(com.liferay.portal.kernel.model.BaseModel)
    • update

      public static BackgroundTask update(BackgroundTask backgroundTask, com.liferay.portal.kernel.service.ServiceContext serviceContext)
      See Also:
      • BasePersistence.update(com.liferay.portal.kernel.model.BaseModel, ServiceContext)
    • findByGroupId

      public static List<BackgroundTask> findByGroupId(long groupId)
      Returns all the background tasks where groupId = ?.
      Parameters:
      groupId - the group ID
      Returns:
      the matching background tasks
    • findByGroupId

      public static List<BackgroundTask> findByGroupId(long groupId, int start, int end)
      Returns a range of all the background tasks where groupId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByGroupId

      public static List<BackgroundTask> findByGroupId(long groupId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByGroupId

      public static List<BackgroundTask> findByGroupId(long groupId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByGroupId_First

      public static BackgroundTask findByGroupId_First(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ?.
      Parameters:
      groupId - the group ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByGroupId_First

      public static BackgroundTask fetchByGroupId_First(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ?.
      Parameters:
      groupId - the group ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByGroupId_Last

      public static BackgroundTask findByGroupId_Last(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ?.
      Parameters:
      groupId - the group ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByGroupId_Last

      public static BackgroundTask fetchByGroupId_Last(long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ?.
      Parameters:
      groupId - the group ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByGroupId_PrevAndNext

      public static BackgroundTask[] findByGroupId_PrevAndNext(long backgroundTaskId, long groupId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • removeByGroupId

      public static void removeByGroupId(long groupId)
      Removes all the background tasks where groupId = ? from the database.
      Parameters:
      groupId - the group ID
    • countByGroupId

      public static int countByGroupId(long groupId)
      Returns the number of background tasks where groupId = ?.
      Parameters:
      groupId - the group ID
      Returns:
      the number of matching background tasks
    • findByCompanyId

      public static List<BackgroundTask> findByCompanyId(long companyId)
      Returns all the background tasks where companyId = ?.
      Parameters:
      companyId - the company ID
      Returns:
      the matching background tasks
    • findByCompanyId

      public static List<BackgroundTask> findByCompanyId(long companyId, int start, int end)
      Returns a range of all the background tasks where companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      companyId - the company ID
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByCompanyId

      public static List<BackgroundTask> findByCompanyId(long companyId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      companyId - the company ID
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByCompanyId

      public static List<BackgroundTask> findByCompanyId(long companyId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where companyId = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      companyId - the company ID
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByCompanyId_First

      public static BackgroundTask findByCompanyId_First(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByCompanyId_First

      public static BackgroundTask fetchByCompanyId_First(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByCompanyId_Last

      public static BackgroundTask findByCompanyId_Last(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByCompanyId_Last

      public static BackgroundTask fetchByCompanyId_Last(long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where companyId = ?.
      Parameters:
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByCompanyId_PrevAndNext

      public static BackgroundTask[] findByCompanyId_PrevAndNext(long backgroundTaskId, long companyId, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where companyId = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      companyId - the company ID
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • removeByCompanyId

      public static void removeByCompanyId(long companyId)
      Removes all the background tasks where companyId = ? from the database.
      Parameters:
      companyId - the company ID
    • countByCompanyId

      public static int countByCompanyId(long companyId)
      Returns the number of background tasks where companyId = ?.
      Parameters:
      companyId - the company ID
      Returns:
      the number of matching background tasks
    • findByCompleted

      public static List<BackgroundTask> findByCompleted(boolean completed)
      Returns all the background tasks where completed = ?.
      Parameters:
      completed - the completed
      Returns:
      the matching background tasks
    • findByCompleted

      public static List<BackgroundTask> findByCompleted(boolean completed, int start, int end)
      Returns a range of all the background tasks where completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByCompleted

      public static List<BackgroundTask> findByCompleted(boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByCompleted

      public static List<BackgroundTask> findByCompleted(boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByCompleted_First

      public static BackgroundTask findByCompleted_First(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where completed = ?.
      Parameters:
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByCompleted_First

      public static BackgroundTask fetchByCompleted_First(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where completed = ?.
      Parameters:
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByCompleted_Last

      public static BackgroundTask findByCompleted_Last(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where completed = ?.
      Parameters:
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByCompleted_Last

      public static BackgroundTask fetchByCompleted_Last(boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where completed = ?.
      Parameters:
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByCompleted_PrevAndNext

      public static BackgroundTask[] findByCompleted_PrevAndNext(long backgroundTaskId, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where completed = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • removeByCompleted

      public static void removeByCompleted(boolean completed)
      Removes all the background tasks where completed = ? from the database.
      Parameters:
      completed - the completed
    • countByCompleted

      public static int countByCompleted(boolean completed)
      Returns the number of background tasks where completed = ?.
      Parameters:
      completed - the completed
      Returns:
      the number of matching background tasks
    • findByStatus

      public static List<BackgroundTask> findByStatus(int status)
      Returns all the background tasks where status = ?.
      Parameters:
      status - the status
      Returns:
      the matching background tasks
    • findByStatus

      public static List<BackgroundTask> findByStatus(int status, int start, int end)
      Returns a range of all the background tasks where status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByStatus

      public static List<BackgroundTask> findByStatus(int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByStatus

      public static List<BackgroundTask> findByStatus(int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByStatus_First

      public static BackgroundTask findByStatus_First(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where status = ?.
      Parameters:
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByStatus_First

      public static BackgroundTask fetchByStatus_First(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where status = ?.
      Parameters:
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByStatus_Last

      public static BackgroundTask findByStatus_Last(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where status = ?.
      Parameters:
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByStatus_Last

      public static BackgroundTask fetchByStatus_Last(int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where status = ?.
      Parameters:
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByStatus_PrevAndNext

      public static BackgroundTask[] findByStatus_PrevAndNext(long backgroundTaskId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where status = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • removeByStatus

      public static void removeByStatus(int status)
      Removes all the background tasks where status = ? from the database.
      Parameters:
      status - the status
    • countByStatus

      public static int countByStatus(int status)
      Returns the number of background tasks where status = ?.
      Parameters:
      status - the status
      Returns:
      the number of matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long groupId, String taskExecutorClassName)
      Returns all the background tasks where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      Returns:
      the matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long groupId, String taskExecutorClassName, int start, int end)
      Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long groupId, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long groupId, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByG_T_First

      public static BackgroundTask findByG_T_First(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByG_T_First

      public static BackgroundTask fetchByG_T_First(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByG_T_Last

      public static BackgroundTask findByG_T_Last(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByG_T_Last

      public static BackgroundTask fetchByG_T_Last(long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByG_T_PrevAndNext

      public static BackgroundTask[] findByG_T_PrevAndNext(long backgroundTaskId, long groupId, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • findByG_T

      public static List<BackgroundTask> findByG_T(long[] groupIds, String[] taskExecutorClassNames)
      Returns all the background tasks where groupId = any ? and taskExecutorClassName = any ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      Returns:
      the matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long[] groupIds, String[] taskExecutorClassNames, int start, int end)
      Returns a range of all the background tasks where groupId = any ? and taskExecutorClassName = any ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long[] groupIds, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = any ? and taskExecutorClassName = any ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_T

      public static List<BackgroundTask> findByG_T(long[] groupIds, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?, optionally using the finder cache.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • removeByG_T

      public static void removeByG_T(long groupId, String taskExecutorClassName)
      Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
    • countByG_T

      public static int countByG_T(long groupId, String taskExecutorClassName)
      Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      Returns:
      the number of matching background tasks
    • countByG_T

      public static int countByG_T(long[] groupIds, String[] taskExecutorClassNames)
      Returns the number of background tasks where groupId = any ? and taskExecutorClassName = any ?.
      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      Returns:
      the number of matching background tasks
    • findByG_S

      public static List<BackgroundTask> findByG_S(long groupId, int status)
      Returns all the background tasks where groupId = ? and status = ?.
      Parameters:
      groupId - the group ID
      status - the status
      Returns:
      the matching background tasks
    • findByG_S

      public static List<BackgroundTask> findByG_S(long groupId, int status, int start, int end)
      Returns a range of all the background tasks where groupId = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_S

      public static List<BackgroundTask> findByG_S(long groupId, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_S

      public static List<BackgroundTask> findByG_S(long groupId, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByG_S_First

      public static BackgroundTask findByG_S_First(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ? and status = ?.
      Parameters:
      groupId - the group ID
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByG_S_First

      public static BackgroundTask fetchByG_S_First(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ? and status = ?.
      Parameters:
      groupId - the group ID
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByG_S_Last

      public static BackgroundTask findByG_S_Last(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ? and status = ?.
      Parameters:
      groupId - the group ID
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByG_S_Last

      public static BackgroundTask fetchByG_S_Last(long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ? and status = ?.
      Parameters:
      groupId - the group ID
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByG_S_PrevAndNext

      public static BackgroundTask[] findByG_S_PrevAndNext(long backgroundTaskId, long groupId, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • removeByG_S

      public static void removeByG_S(long groupId, int status)
      Removes all the background tasks where groupId = ? and status = ? from the database.
      Parameters:
      groupId - the group ID
      status - the status
    • countByG_S

      public static int countByG_S(long groupId, int status)
      Returns the number of background tasks where groupId = ? and status = ?.
      Parameters:
      groupId - the group ID
      status - the status
      Returns:
      the number of matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String taskExecutorClassName, int status)
      Returns all the background tasks where taskExecutorClassName = ? and status = ?.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      Returns:
      the matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String taskExecutorClassName, int status, int start, int end)
      Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByT_S_First

      public static BackgroundTask findByT_S_First(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByT_S_First

      public static BackgroundTask fetchByT_S_First(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByT_S_Last

      public static BackgroundTask findByT_S_Last(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByT_S_Last

      public static BackgroundTask fetchByT_S_Last(String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByT_S_PrevAndNext

      public static BackgroundTask[] findByT_S_PrevAndNext(long backgroundTaskId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • findByT_S

      public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames, int status)
      Returns all the background tasks where taskExecutorClassName = any ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassNames - the task executor class names
      status - the status
      Returns:
      the matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames, int status, int start, int end)
      Returns a range of all the background tasks where taskExecutorClassName = any ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassNames - the task executor class names
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where taskExecutorClassName = any ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassNames - the task executor class names
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByT_S

      public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?, optionally using the finder cache.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      taskExecutorClassNames - the task executor class names
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • removeByT_S

      public static void removeByT_S(String taskExecutorClassName, int status)
      Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
    • countByT_S

      public static int countByT_S(String taskExecutorClassName, int status)
      Returns the number of background tasks where taskExecutorClassName = ? and status = ?.
      Parameters:
      taskExecutorClassName - the task executor class name
      status - the status
      Returns:
      the number of matching background tasks
    • countByT_S

      public static int countByT_S(String[] taskExecutorClassNames, int status)
      Returns the number of background tasks where taskExecutorClassName = any ? and status = ?.
      Parameters:
      taskExecutorClassNames - the task executor class names
      status - the status
      Returns:
      the number of matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long groupId, String name, String taskExecutorClassName)
      Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      Returns:
      the matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long groupId, String name, String taskExecutorClassName, int start, int end)
      Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long groupId, String name, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long groupId, String name, String taskExecutorClassName, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByG_N_T_First

      public static BackgroundTask findByG_N_T_First(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByG_N_T_First

      public static BackgroundTask fetchByG_N_T_First(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByG_N_T_Last

      public static BackgroundTask findByG_N_T_Last(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByG_N_T_Last

      public static BackgroundTask fetchByG_N_T_Last(long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByG_N_T_PrevAndNext

      public static BackgroundTask[] findByG_N_T_PrevAndNext(long backgroundTaskId, long groupId, String name, String taskExecutorClassName, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames)
      Returns all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassNames - the task executor class names
      Returns:
      the matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames, int start, int end)
      Returns a range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassNames - the task executor class names
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassNames - the task executor class names
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_N_T

      public static List<BackgroundTask> findByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?, optionally using the finder cache.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassNames - the task executor class names
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • removeByG_N_T

      public static void removeByG_N_T(long groupId, String name, String taskExecutorClassName)
      Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
    • countByG_N_T

      public static int countByG_N_T(long groupId, String name, String taskExecutorClassName)
      Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      Returns:
      the number of matching background tasks
    • countByG_N_T

      public static int countByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames)
      Returns the number of background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.
      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassNames - the task executor class names
      Returns:
      the number of matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
      Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      Returns:
      the matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long groupId, String taskExecutorClassName, boolean completed, int start, int end)
      Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long groupId, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long groupId, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByG_T_C_First

      public static BackgroundTask findByG_T_C_First(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByG_T_C_First

      public static BackgroundTask fetchByG_T_C_First(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByG_T_C_Last

      public static BackgroundTask findByG_T_C_Last(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByG_T_C_Last

      public static BackgroundTask fetchByG_T_C_Last(long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByG_T_C_PrevAndNext

      public static BackgroundTask[] findByG_T_C_PrevAndNext(long backgroundTaskId, long groupId, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed)
      Returns all the background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      completed - the completed
      Returns:
      the matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed, int start, int end)
      Returns a range of all the background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_T_C

      public static List<BackgroundTask> findByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?, optionally using the finder cache.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • removeByG_T_C

      public static void removeByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
      Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
    • countByG_T_C

      public static int countByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
      Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      completed - the completed
      Returns:
      the number of matching background tasks
    • countByG_T_C

      public static int countByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed)
      Returns the number of background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.
      Parameters:
      groupIds - the group IDs
      taskExecutorClassNames - the task executor class names
      completed - the completed
      Returns:
      the number of matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String taskExecutorClassName, int status)
      Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      Returns:
      the matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String taskExecutorClassName, int status, int start, int end)
      Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String taskExecutorClassName, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByG_T_S_First

      public static BackgroundTask findByG_T_S_First(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByG_T_S_First

      public static BackgroundTask fetchByG_T_S_First(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByG_T_S_Last

      public static BackgroundTask findByG_T_S_Last(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByG_T_S_Last

      public static BackgroundTask fetchByG_T_S_Last(long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByG_T_S_PrevAndNext

      public static BackgroundTask[] findByG_T_S_PrevAndNext(long backgroundTaskId, long groupId, String taskExecutorClassName, int status, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, int status)
      Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassNames - the task executor class names
      status - the status
      Returns:
      the matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, int status, int start, int end)
      Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassNames - the task executor class names
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassNames - the task executor class names
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_T_S

      public static List<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, int status, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?, optionally using the finder cache.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      taskExecutorClassNames - the task executor class names
      status - the status
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • removeByG_T_S

      public static void removeByG_T_S(long groupId, String taskExecutorClassName, int status)
      Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
    • countByG_T_S

      public static int countByG_T_S(long groupId, String taskExecutorClassName, int status)
      Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassName - the task executor class name
      status - the status
      Returns:
      the number of matching background tasks
    • countByG_T_S

      public static int countByG_T_S(long groupId, String[] taskExecutorClassNames, int status)
      Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.
      Parameters:
      groupId - the group ID
      taskExecutorClassNames - the task executor class names
      status - the status
      Returns:
      the number of matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed)
      Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      Returns:
      the matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed, int start, int end)
      Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • findByG_N_T_C_First

      public static BackgroundTask findByG_N_T_C_First(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task
    • fetchByG_N_T_C_First

      public static BackgroundTask fetchByG_N_T_C_First(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the first matching background task, or null if a matching background task could not be found
    • findByG_N_T_C_Last

      public static BackgroundTask findByG_N_T_C_Last(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task
    • fetchByG_N_T_C_Last

      public static BackgroundTask fetchByG_N_T_C_Last(long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the last matching background task, or null if a matching background task could not be found
    • findByG_N_T_C_PrevAndNext

      public static BackgroundTask[] findByG_N_T_C_PrevAndNext(long backgroundTaskId, long groupId, String name, String taskExecutorClassName, boolean completed, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) throws NoSuchBackgroundTaskException
      Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      backgroundTaskId - the primary key of the current background task
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      orderByComparator - the comparator to order the set by (optionally null)
      Returns:
      the previous, current, and next background task
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed)
      Returns all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      Returns:
      the matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed, int start, int end)
      Returns a range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of matching background tasks
    • findByG_N_T_C

      public static List<BackgroundTask> findByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?, optionally using the finder cache.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of matching background tasks
    • removeByG_N_T_C

      public static void removeByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed)
      Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ? from the database.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
    • countByG_N_T_C

      public static int countByG_N_T_C(long groupId, String name, String taskExecutorClassName, boolean completed)
      Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupId - the group ID
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      Returns:
      the number of matching background tasks
    • countByG_N_T_C

      public static int countByG_N_T_C(long[] groupIds, String name, String taskExecutorClassName, boolean completed)
      Returns the number of background tasks where groupId = any ? and name = ? and taskExecutorClassName = ? and completed = ?.
      Parameters:
      groupIds - the group IDs
      name - the name
      taskExecutorClassName - the task executor class name
      completed - the completed
      Returns:
      the number of matching background tasks
    • cacheResult

      public static void cacheResult(BackgroundTask backgroundTask)
      Caches the background task in the entity cache if it is enabled.
      Parameters:
      backgroundTask - the background task
    • cacheResult

      public static void cacheResult(List<BackgroundTask> backgroundTasks)
      Caches the background tasks in the entity cache if it is enabled.
      Parameters:
      backgroundTasks - the background tasks
    • create

      public static BackgroundTask create(long backgroundTaskId)
      Creates a new background task with the primary key. Does not add the background task to the database.
      Parameters:
      backgroundTaskId - the primary key for the new background task
      Returns:
      the new background task
    • remove

      public static BackgroundTask remove(long backgroundTaskId) throws NoSuchBackgroundTaskException
      Removes the background task with the primary key from the database. Also notifies the appropriate model listeners.
      Parameters:
      backgroundTaskId - the primary key of the background task
      Returns:
      the background task that was removed
    • updateImpl

      public static BackgroundTask updateImpl(BackgroundTask backgroundTask)
    • findByPrimaryKey

      public static BackgroundTask findByPrimaryKey(long backgroundTaskId) throws NoSuchBackgroundTaskException
      Returns the background task with the primary key or throws a NoSuchBackgroundTaskException if it could not be found.
      Parameters:
      backgroundTaskId - the primary key of the background task
      Returns:
      the background task
    • fetchByPrimaryKey

      public static BackgroundTask fetchByPrimaryKey(long backgroundTaskId)
      Returns the background task with the primary key or returns null if it could not be found.
      Parameters:
      backgroundTaskId - the primary key of the background task
      Returns:
      the background task, or null if a background task with the primary key could not be found
    • findAll

      public static List<BackgroundTask> findAll()
      Returns all the background tasks.
      Returns:
      the background tasks
    • findAll

      public static List<BackgroundTask> findAll(int start, int end)
      Returns a range of all the background tasks.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      Returns:
      the range of background tasks
    • findAll

      public static List<BackgroundTask> findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator)
      Returns an ordered range of all the background tasks.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      Returns:
      the ordered range of background tasks
    • findAll

      public static List<BackgroundTask> findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator, boolean useFinderCache)
      Returns an ordered range of all the background tasks.

      Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent, then the query will include the default ORDER BY logic from BackgroundTaskModelImpl.

      Parameters:
      start - the lower bound of the range of background tasks
      end - the upper bound of the range of background tasks (not inclusive)
      orderByComparator - the comparator to order the results by (optionally null)
      useFinderCache - whether to use the finder cache
      Returns:
      the ordered range of background tasks
    • removeAll

      public static void removeAll()
      Removes all the background tasks from the database.
    • countAll

      public static int countAll()
      Returns the number of background tasks.
      Returns:
      the number of background tasks
    • getPersistence

      public static BackgroundTaskPersistence getPersistence()
    • setPersistence

      public static void setPersistence(BackgroundTaskPersistence persistence)