|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.liferay.portlet.calendar.service.persistence.CalEventUtil
@Deprecated @ProviderType public class CalEventUtil
The persistence utility for the cal event service. This utility wraps com.liferay.portlet.calendar.service.persistence.impl.CalEventPersistenceImpl and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
Caching information and settings can be found in portal.properties
CalEventPersistence,
com.liferay.portlet.calendar.service.persistence.impl.CalEventPersistenceImpl| Constructor Summary | |
|---|---|
CalEventUtil()
Deprecated. |
|
| Method Summary | |
|---|---|
static void |
cacheResult(CalEvent calEvent)
Deprecated. Caches the cal event in the entity cache if it is enabled. |
static void |
cacheResult(List<CalEvent> calEvents)
Deprecated. Caches the cal events in the entity cache if it is enabled. |
static void |
clearCache()
Deprecated. |
static void |
clearCache(CalEvent calEvent)
Deprecated. |
static int |
countAll()
Deprecated. Returns the number of cal events. |
static int |
countByCompanyId(long companyId)
Deprecated. Returns the number of cal events where companyId = ?. |
static int |
countByG_R(long groupId,
boolean repeating)
Deprecated. Returns the number of cal events where groupId = ? and repeating = ?. |
static int |
countByG_T_R(long groupId,
String[] types,
boolean repeating)
Deprecated. Returns the number of cal events where groupId = ? and type = any ? and repeating = ?. |
static int |
countByG_T_R(long groupId,
String type,
boolean repeating)
Deprecated. Returns the number of cal events where groupId = ? and type = ? and repeating = ?. |
static int |
countByG_T(long groupId,
String type)
Deprecated. Returns the number of cal events where groupId = ? and type = ?. |
static int |
countByG_T(long groupId,
String[] types)
Deprecated. Returns the number of cal events where groupId = ? and type = any ?. |
static int |
countByGroupId(long groupId)
Deprecated. Returns the number of cal events where groupId = ?. |
static int |
countByNotRemindBy(int remindBy)
Deprecated. Returns the number of cal events where remindBy ≠ ?. |
static int |
countByUuid_C(String uuid,
long companyId)
Deprecated. Returns the number of cal events where uuid = ? and companyId = ?. |
static int |
countByUUID_G(String uuid,
long groupId)
Deprecated. Returns the number of cal events where uuid = ? and groupId = ?. |
static int |
countByUuid(String uuid)
Deprecated. Returns the number of cal events where uuid = ?. |
static long |
countWithDynamicQuery(DynamicQuery dynamicQuery)
Deprecated. |
static CalEvent |
create(long eventId)
Deprecated. Creates a new cal event with the primary key. |
static CalEvent |
fetchByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where companyId = ?. |
static CalEvent |
fetchByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where companyId = ?. |
static CalEvent |
fetchByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and repeating = ?. |
static CalEvent |
fetchByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and repeating = ?. |
static CalEvent |
fetchByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ?. |
static CalEvent |
fetchByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ?. |
static CalEvent |
fetchByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
static CalEvent |
fetchByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
static CalEvent |
fetchByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ?. |
static CalEvent |
fetchByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ?. |
static CalEvent |
fetchByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where remindBy ≠ ?. |
static CalEvent |
fetchByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where remindBy ≠ ?. |
static CalEvent |
fetchByPrimaryKey(long eventId)
Deprecated. Returns the cal event with the primary key or returns null if it could not be found. |
static Map<Serializable,CalEvent> |
fetchByPrimaryKeys(Set<Serializable> primaryKeys)
Deprecated. |
static CalEvent |
fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ? and companyId = ?. |
static CalEvent |
fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ? and companyId = ?. |
static CalEvent |
fetchByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ?. |
static CalEvent |
fetchByUUID_G(String uuid,
long groupId)
Deprecated. Returns the cal event where uuid = ? and groupId = ? or returns null if it could not be found. |
static CalEvent |
fetchByUUID_G(String uuid,
long groupId,
boolean retrieveFromCache)
Deprecated. Returns the cal event where uuid = ? and groupId = ? or returns null if it could not be found, optionally using the finder cache. |
static CalEvent |
fetchByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ?. |
static List<CalEvent> |
findAll()
Deprecated. Returns all the cal events. |
static List<CalEvent> |
findAll(int start,
int end)
Deprecated. Returns a range of all the cal events. |
static List<CalEvent> |
findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events. |
static List<CalEvent> |
findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events. |
static CalEvent |
findByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where companyId = ?. |
static CalEvent |
findByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where companyId = ?. |
static CalEvent[] |
findByCompanyId_PrevAndNext(long eventId,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where companyId = ?. |
static List<CalEvent> |
findByCompanyId(long companyId)
Deprecated. Returns all the cal events where companyId = ?. |
static List<CalEvent> |
findByCompanyId(long companyId,
int start,
int end)
Deprecated. Returns a range of all the cal events where companyId = ?. |
static List<CalEvent> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where companyId = ?. |
static List<CalEvent> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where companyId = ?. |
static CalEvent |
findByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and repeating = ?. |
static CalEvent |
findByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and repeating = ?. |
static CalEvent[] |
findByG_R_PrevAndNext(long eventId,
long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ? and repeating = ?. |
static List<CalEvent> |
findByG_R(long groupId,
boolean repeating)
Deprecated. Returns all the cal events where groupId = ? and repeating = ?. |
static List<CalEvent> |
findByG_R(long groupId,
boolean repeating,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and repeating = ?. |
static List<CalEvent> |
findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and repeating = ?. |
static List<CalEvent> |
findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and repeating = ?. |
static CalEvent |
findByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ?. |
static CalEvent |
findByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ?. |
static CalEvent[] |
findByG_T_PrevAndNext(long eventId,
long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ?. |
static CalEvent |
findByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
static CalEvent |
findByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
static CalEvent[] |
findByG_T_R_PrevAndNext(long eventId,
long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating)
Deprecated. Returns all the cal events where groupId = ? and type = any ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = any ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = any ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?, optionally using the finder cache. |
static List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating)
Deprecated. Returns all the cal events where groupId = ? and type = ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. |
static List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. |
static List<CalEvent> |
findByG_T(long groupId,
String type)
Deprecated. Returns all the cal events where groupId = ? and type = ?. |
static List<CalEvent> |
findByG_T(long groupId,
String[] types)
Deprecated. Returns all the cal events where groupId = ? and type = any ?. |
static List<CalEvent> |
findByG_T(long groupId,
String[] types,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = any ?. |
static List<CalEvent> |
findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = any ?. |
static List<CalEvent> |
findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ?, optionally using the finder cache. |
static List<CalEvent> |
findByG_T(long groupId,
String type,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = ?. |
static List<CalEvent> |
findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ?. |
static List<CalEvent> |
findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ?. |
static CalEvent |
findByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ?. |
static CalEvent |
findByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ?. |
static CalEvent[] |
findByGroupId_PrevAndNext(long eventId,
long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ?. |
static List<CalEvent> |
findByGroupId(long groupId)
Deprecated. Returns all the cal events where groupId = ?. |
static List<CalEvent> |
findByGroupId(long groupId,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ?. |
static List<CalEvent> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ?. |
static List<CalEvent> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ?. |
static CalEvent |
findByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where remindBy ≠ ?. |
static CalEvent |
findByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where remindBy ≠ ?. |
static CalEvent[] |
findByNotRemindBy_PrevAndNext(long eventId,
int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where remindBy ≠ ?. |
static List<CalEvent> |
findByNotRemindBy(int remindBy)
Deprecated. Returns all the cal events where remindBy ≠ ?. |
static List<CalEvent> |
findByNotRemindBy(int remindBy,
int start,
int end)
Deprecated. Returns a range of all the cal events where remindBy ≠ ?. |
static List<CalEvent> |
findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where remindBy ≠ ?. |
static List<CalEvent> |
findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where remindBy ≠ ?. |
static CalEvent |
findByPrimaryKey(long eventId)
Deprecated. Returns the cal event with the primary key or throws a NoSuchEventException if it could not be found. |
static CalEvent |
findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ? and companyId = ?. |
static CalEvent |
findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ? and companyId = ?. |
static CalEvent[] |
findByUuid_C_PrevAndNext(long eventId,
String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where uuid = ? and companyId = ?. |
static List<CalEvent> |
findByUuid_C(String uuid,
long companyId)
Deprecated. Returns all the cal events where uuid = ? and companyId = ?. |
static List<CalEvent> |
findByUuid_C(String uuid,
long companyId,
int start,
int end)
Deprecated. Returns a range of all the cal events where uuid = ? and companyId = ?. |
static List<CalEvent> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where uuid = ? and companyId = ?. |
static List<CalEvent> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where uuid = ? and companyId = ?. |
static CalEvent |
findByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ?. |
static CalEvent |
findByUUID_G(String uuid,
long groupId)
Deprecated. Returns the cal event where uuid = ? and groupId = ? or throws a NoSuchEventException if it could not be found. |
static CalEvent |
findByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ?. |
static CalEvent[] |
findByUuid_PrevAndNext(long eventId,
String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where uuid = ?. |
static List<CalEvent> |
findByUuid(String uuid)
Deprecated. Returns all the cal events where uuid = ?. |
static List<CalEvent> |
findByUuid(String uuid,
int start,
int end)
Deprecated. Returns a range of all the cal events where uuid = ?. |
static List<CalEvent> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where uuid = ?. |
static List<CalEvent> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where uuid = ?. |
static List<CalEvent> |
findWithDynamicQuery(DynamicQuery dynamicQuery)
Deprecated. |
static List<CalEvent> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
Deprecated. |
static List<CalEvent> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. |
static Set<String> |
getBadColumnNames()
Deprecated. |
static CalEventPersistence |
getPersistence()
Deprecated. |
static CalEvent |
remove(long eventId)
Deprecated. Removes the cal event with the primary key from the database. |
static void |
removeAll()
Deprecated. Removes all the cal events from the database. |
static void |
removeByCompanyId(long companyId)
Deprecated. Removes all the cal events where companyId = ? from the database. |
static void |
removeByG_R(long groupId,
boolean repeating)
Deprecated. Removes all the cal events where groupId = ? and repeating = ? from the database. |
static void |
removeByG_T_R(long groupId,
String type,
boolean repeating)
Deprecated. Removes all the cal events where groupId = ? and type = ? and repeating = ? from the database. |
static void |
removeByG_T(long groupId,
String type)
Deprecated. Removes all the cal events where groupId = ? and type = ? from the database. |
static void |
removeByGroupId(long groupId)
Deprecated. Removes all the cal events where groupId = ? from the database. |
static void |
removeByNotRemindBy(int remindBy)
Deprecated. Removes all the cal events where remindBy ≠ ? from the database. |
static void |
removeByUuid_C(String uuid,
long companyId)
Deprecated. Removes all the cal events where uuid = ? and companyId = ? from the database. |
static CalEvent |
removeByUUID_G(String uuid,
long groupId)
Deprecated. Removes the cal event where uuid = ? and groupId = ? from the database. |
static void |
removeByUuid(String uuid)
Deprecated. Removes all the cal events where uuid = ? from the database. |
static CalEvent |
update(CalEvent calEvent)
Deprecated. |
static CalEvent |
update(CalEvent calEvent,
ServiceContext serviceContext)
Deprecated. |
static CalEvent |
updateImpl(CalEvent calEvent)
Deprecated. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public CalEventUtil()
| Method Detail |
|---|
public static void clearCache()
BasePersistence.clearCache()public static void clearCache(CalEvent calEvent)
BasePersistence.clearCache(com.liferay.portal.model.BaseModel)public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.countWithDynamicQuery(DynamicQuery)public static List<CalEvent> findWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.findWithDynamicQuery(DynamicQuery)
public static List<CalEvent> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
public static List<CalEvent> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)public static CalEvent update(CalEvent calEvent)
BasePersistence.update(com.liferay.portal.model.BaseModel)
public static CalEvent update(CalEvent calEvent,
ServiceContext serviceContext)
BasePersistence.update(com.liferay.portal.model.BaseModel, ServiceContext)public static List<CalEvent> findByUuid(String uuid)
uuid - the uuid
public static List<CalEvent> findByUuid(String uuid,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
uuid - the uuidstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
uuid - the uuidstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
uuid - the uuidstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByUuid_PrevAndNext(long eventId,
String uuid,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventuuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundpublic static void removeByUuid(String uuid)
uuid - the uuidpublic static int countByUuid(String uuid)
uuid - the uuid
public static CalEvent findByUUID_G(String uuid,
long groupId)
throws NoSuchEventException
NoSuchEventException if it could not be found.
uuid - the uuidgroupId - the group ID
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByUUID_G(String uuid,
long groupId)
null if it could not be found. Uses the finder cache.
uuid - the uuidgroupId - the group ID
null if a matching cal event could not be found
public static CalEvent fetchByUUID_G(String uuid,
long groupId,
boolean retrieveFromCache)
null if it could not be found, optionally using the finder cache.
uuid - the uuidgroupId - the group IDretrieveFromCache - whether to retrieve from the finder cache
null if a matching cal event could not be found
public static CalEvent removeByUUID_G(String uuid,
long groupId)
throws NoSuchEventException
uuid - the uuidgroupId - the group ID
NoSuchEventException
public static int countByUUID_G(String uuid,
long groupId)
uuid - the uuidgroupId - the group ID
public static List<CalEvent> findByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<CalEvent> findByUuid_C(String uuid,
long companyId,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByUuid_C_PrevAndNext(long eventId,
String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventuuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
public static void removeByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static int countByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<CalEvent> findByGroupId(long groupId)
groupId - the group ID
public static List<CalEvent> findByGroupId(long groupId,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByGroupId_PrevAndNext(long eventId,
long groupId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundpublic static void removeByGroupId(long groupId)
groupId - the group IDpublic static int countByGroupId(long groupId)
groupId - the group ID
public static List<CalEvent> findByCompanyId(long companyId)
companyId - the company ID
public static List<CalEvent> findByCompanyId(long companyId,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
companyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
companyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
companyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByCompanyId_PrevAndNext(long eventId,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundpublic static void removeByCompanyId(long companyId)
companyId - the company IDpublic static int countByCompanyId(long companyId)
companyId - the company ID
public static List<CalEvent> findByNotRemindBy(int remindBy)
remindBy - the remind by
public static List<CalEvent> findByNotRemindBy(int remindBy,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
remindBy - the remind bystart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
remindBy - the remind bystart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
remindBy - the remind bystart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByNotRemindBy_PrevAndNext(long eventId,
int remindBy,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventremindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundpublic static void removeByNotRemindBy(int remindBy)
remindBy - the remind bypublic static int countByNotRemindBy(int remindBy)
remindBy - the remind by
public static List<CalEvent> findByG_T(long groupId,
String type)
groupId - the group IDtype - the type
public static List<CalEvent> findByG_T(long groupId,
String type,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByG_T_PrevAndNext(long eventId,
long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
public static List<CalEvent> findByG_T(long groupId,
String[] types)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtypes - the types
public static List<CalEvent> findByG_T(long groupId,
String[] types,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtypes - the typesstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtypes - the typesstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static void removeByG_T(long groupId,
String type)
groupId - the group IDtype - the type
public static int countByG_T(long groupId,
String type)
groupId - the group IDtype - the type
public static int countByG_T(long groupId,
String[] types)
groupId - the group IDtypes - the types
public static List<CalEvent> findByG_R(long groupId,
boolean repeating)
groupId - the group IDrepeating - the repeating
public static List<CalEvent> findByG_R(long groupId,
boolean repeating,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByG_R_PrevAndNext(long eventId,
long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
public static void removeByG_R(long groupId,
boolean repeating)
groupId - the group IDrepeating - the repeating
public static int countByG_R(long groupId,
boolean repeating)
groupId - the group IDrepeating - the repeating
public static List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating)
groupId - the group IDtype - the typerepeating - the repeating
public static List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static CalEvent findByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent findByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
public static CalEvent fetchByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
public static CalEvent[] findByG_T_R_PrevAndNext(long eventId,
long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
public static List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtypes - the typesrepeating - the repeating
public static List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtypes - the typesrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtypes - the typesrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static void removeByG_T_R(long groupId,
String type,
boolean repeating)
groupId - the group IDtype - the typerepeating - the repeating
public static int countByG_T_R(long groupId,
String type,
boolean repeating)
groupId - the group IDtype - the typerepeating - the repeating
public static int countByG_T_R(long groupId,
String[] types,
boolean repeating)
groupId - the group IDtypes - the typesrepeating - the repeating
public static void cacheResult(CalEvent calEvent)
calEvent - the cal eventpublic static void cacheResult(List<CalEvent> calEvents)
calEvents - the cal eventspublic static CalEvent create(long eventId)
eventId - the primary key for the new cal event
public static CalEvent remove(long eventId)
throws NoSuchEventException
eventId - the primary key of the cal event
NoSuchEventException - if a cal event with the primary key could not be foundpublic static CalEvent updateImpl(CalEvent calEvent)
public static CalEvent findByPrimaryKey(long eventId)
throws NoSuchEventException
NoSuchEventException if it could not be found.
eventId - the primary key of the cal event
NoSuchEventException - if a cal event with the primary key could not be foundpublic static CalEvent fetchByPrimaryKey(long eventId)
null if it could not be found.
eventId - the primary key of the cal event
null if a cal event with the primary key could not be foundpublic static Map<Serializable,CalEvent> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
public static List<CalEvent> findAll()
public static List<CalEvent> findAll(int start,
int end)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
start - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
public static List<CalEvent> findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
start - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<CalEvent> findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from CalEventModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
start - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static void removeAll()
public static int countAll()
public static Set<String> getBadColumnNames()
public static CalEventPersistence getPersistence()
|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||