Interface BackgroundTaskPersistence

All Superinterfaces:
com.liferay.portal.kernel.service.persistence.BasePersistence<BackgroundTask>

@ProviderType public interface BackgroundTaskPersistence extends com.liferay.portal.kernel.service.persistence.BasePersistence<BackgroundTask>
The persistence interface for the background task service.

Caching information and settings can be found in portal.properties

See Also:
Generated:
  • Method Summary

    Modifier and Type
    Method
    Description
    void
    cacheResult(BackgroundTask backgroundTask)
    Caches the background task in the entity cache if it is enabled.
    void
    cacheResult(List<BackgroundTask> backgroundTasks)
    Caches the background tasks in the entity cache if it is enabled.
    int
    Returns the number of background tasks.
    int
    countByCompanyId(long companyId)
    Returns the number of background tasks where companyId = ?.
    int
    countByCompleted(boolean completed)
    Returns the number of background tasks where completed = ?.
    int
    countByG_N_T(long[] groupIds, String name, String[] taskExecutorClassNames)
    Returns the number of background tasks where groupId = any ? and name = ? and taskExecutorClassName = any ?.
    int
    countByG_N_T(long groupId, String name, String taskExecutorClassName)
    Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?.
    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 = ?.
    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 = ?.
    int
    countByG_S(long groupId, int status)
    Returns the number of background tasks where groupId = ? and status = ?.
    int
    countByG_T(long[] groupIds, String[] taskExecutorClassNames)
    Returns the number of background tasks where groupId = any ? and taskExecutorClassName = any ?.
    int
    countByG_T(long groupId, String taskExecutorClassName)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?.
    int
    countByG_T_C(long[] groupIds, String[] taskExecutorClassNames, boolean completed)
    Returns the number of background tasks where groupId = any ? and taskExecutorClassName = any ? and completed = ?.
    int
    countByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?.
    int
    countByG_T_S(long groupId, String[] taskExecutorClassNames, int status)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?.
    int
    countByG_T_S(long groupId, String taskExecutorClassName, int status)
    Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?.
    int
    countByGroupId(long groupId)
    Returns the number of background tasks where groupId = ?.
    int
    countByStatus(int status)
    Returns the number of background tasks where status = ?.
    int
    countByT_S(String[] taskExecutorClassNames, int status)
    Returns the number of background tasks where taskExecutorClassName = any ? and status = ?.
    int
    countByT_S(String taskExecutorClassName, int status)
    Returns the number of background tasks where taskExecutorClassName = ? and status = ?.
    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 = ?.
    remove(long backgroundTaskId)
    Removes the background task with the primary key from the database.
    void
    Removes all the background tasks from the database.
    void
    removeByCompanyId(long companyId)
    Removes all the background tasks where companyId = ? from the database.
    void
    removeByCompleted(boolean completed)
    Removes all the background tasks where completed = ? from the database.
    void
    removeByG_N_T(long groupId, String name, String taskExecutorClassName)
    Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database.
    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.
    void
    removeByG_S(long groupId, int status)
    Removes all the background tasks where groupId = ? and status = ? from the database.
    void
    removeByG_T(long groupId, String taskExecutorClassName)
    Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database.
    void
    removeByG_T_C(long groupId, String taskExecutorClassName, boolean completed)
    Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database.
    void
    removeByG_T_S(long groupId, String taskExecutorClassName, int status)
    Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database.
    void
    removeByGroupId(long groupId)
    Removes all the background tasks where groupId = ? from the database.
    void
    removeByStatus(int status)
    Removes all the background tasks where status = ? from the database.
    void
    removeByT_S(String taskExecutorClassName, int status)
    Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database.
    updateImpl(BackgroundTask backgroundTask)
     

    Methods inherited from interface com.liferay.portal.kernel.service.persistence.BasePersistence

    clearCache, clearCache, clearCache, clearCache, closeSession, countWithDynamicQuery, countWithDynamicQuery, dslQuery, dslQueryCount, fetchByPrimaryKey, fetchByPrimaryKeys, findByPrimaryKey, findWithDynamicQuery, findWithDynamicQuery, findWithDynamicQuery, flush, getBadColumnNames, getCurrentSession, getDataSource, getDB, getDialect, getListeners, getModelClass, openSession, processException, registerListener, remove, remove, removeByFunction, setDataSource, unregisterListener, update, update
  • Method Details

    • findByGroupId

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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByGroupId_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByGroupId_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • removeByGroupId

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

      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

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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByCompanyId_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByCompanyId_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • removeByCompanyId

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

      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

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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByCompleted_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByCompleted_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • removeByCompleted

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

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

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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByStatus_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByStatus_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • removeByStatus

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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_T_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_T_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • findByG_T

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_S_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_S_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • removeByG_S

      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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByT_S_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByT_S_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • findByT_S

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_N_T_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_N_T_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • findByG_N_T

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_T_C_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_T_C_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • findByG_T_C

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_T_S_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_T_S_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • findByG_T_S

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_N_T_C_First

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a matching background task could not be found
    • fetchByG_N_T_C_Last

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • findByG_N_T_C

      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

      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

      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

      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

      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

      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

      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

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

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

      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

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • updateImpl

      BackgroundTask updateImpl(BackgroundTask backgroundTask)
    • findByPrimaryKey

      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
      Throws:
      NoSuchBackgroundTaskException - if a background task with the primary key could not be found
    • fetchByPrimaryKey

      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

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

      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

      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

      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

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

      int countAll()
      Returns the number of background tasks.
      Returns:
      the number of background tasks