Liferay 6.1.2-ce-ga3

com.liferay.portlet.softwarecatalog.service.persistence
Interface SCLicensePersistence

All Superinterfaces:
BasePersistence<SCLicense>

public interface SCLicensePersistence
extends BasePersistence<SCLicense>

The persistence interface for the s c license service.

Caching information and settings can be found in portal.properties

See Also:
SCLicensePersistenceImpl, SCLicenseUtil

Method Summary
 void addSCProductEntries(long pk, List<SCProductEntry> scProductEntries)
          Adds an association between the s c license and the s c product entries.
 void addSCProductEntries(long pk, long[] scProductEntryPKs)
          Adds an association between the s c license and the s c product entries.
 void addSCProductEntry(long pk, long scProductEntryPK)
          Adds an association between the s c license and the s c product entry.
 void addSCProductEntry(long pk, SCProductEntry scProductEntry)
          Adds an association between the s c license and the s c product entry.
 void cacheResult(List<SCLicense> scLicenses)
          Caches the s c licenses in the entity cache if it is enabled.
 void cacheResult(SCLicense scLicense)
          Caches the s c license in the entity cache if it is enabled.
 void clearSCProductEntries(long pk)
          Clears all associations between the s c license and its s c product entries.
 boolean containsSCProductEntries(long pk)
          Returns true if the s c license has any s c product entries associated with it.
 boolean containsSCProductEntry(long pk, long scProductEntryPK)
          Returns true if the s c product entry is associated with the s c license.
 int countAll()
          Returns the number of s c licenses.
 int countByA_R(boolean active, boolean recommended)
          Returns the number of s c licenses where active = ? and recommended = ?.
 int countByActive(boolean active)
          Returns the number of s c licenses where active = ?.
 SCLicense create(long licenseId)
          Creates a new s c license with the primary key.
 SCLicense fetchByA_R_First(boolean active, boolean recommended, OrderByComparator orderByComparator)
          Returns the first s c license in the ordered set where active = ? and recommended = ?.
 SCLicense fetchByA_R_Last(boolean active, boolean recommended, OrderByComparator orderByComparator)
          Returns the last s c license in the ordered set where active = ? and recommended = ?.
 SCLicense fetchByActive_First(boolean active, OrderByComparator orderByComparator)
          Returns the first s c license in the ordered set where active = ?.
 SCLicense fetchByActive_Last(boolean active, OrderByComparator orderByComparator)
          Returns the last s c license in the ordered set where active = ?.
 SCLicense fetchByPrimaryKey(long licenseId)
          Returns the s c license with the primary key or returns null if it could not be found.
 int filterCountByA_R(boolean active, boolean recommended)
          Returns the number of s c licenses that the user has permission to view where active = ? and recommended = ?.
 int filterCountByActive(boolean active)
          Returns the number of s c licenses that the user has permission to view where active = ?.
 SCLicense[] filterFindByA_R_PrevAndNext(long licenseId, boolean active, boolean recommended, OrderByComparator orderByComparator)
          Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ? and recommended = ?.
 List<SCLicense> filterFindByA_R(boolean active, boolean recommended)
          Returns all the s c licenses that the user has permission to view where active = ? and recommended = ?.
 List<SCLicense> filterFindByA_R(boolean active, boolean recommended, int start, int end)
          Returns a range of all the s c licenses that the user has permission to view where active = ? and recommended = ?.
 List<SCLicense> filterFindByA_R(boolean active, boolean recommended, int start, int end, OrderByComparator orderByComparator)
          Returns an ordered range of all the s c licenses that the user has permissions to view where active = ? and recommended = ?.
 SCLicense[] filterFindByActive_PrevAndNext(long licenseId, boolean active, OrderByComparator orderByComparator)
          Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ?.
 List<SCLicense> filterFindByActive(boolean active)
          Returns all the s c licenses that the user has permission to view where active = ?.
 List<SCLicense> filterFindByActive(boolean active, int start, int end)
          Returns a range of all the s c licenses that the user has permission to view where active = ?.
 List<SCLicense> filterFindByActive(boolean active, int start, int end, OrderByComparator orderByComparator)
          Returns an ordered range of all the s c licenses that the user has permissions to view where active = ?.
 List<SCLicense> findAll()
          Returns all the s c licenses.
 List<SCLicense> findAll(int start, int end)
          Returns a range of all the s c licenses.
 List<SCLicense> findAll(int start, int end, OrderByComparator orderByComparator)
          Returns an ordered range of all the s c licenses.
 SCLicense findByA_R_First(boolean active, boolean recommended, OrderByComparator orderByComparator)
          Returns the first s c license in the ordered set where active = ? and recommended = ?.
 SCLicense findByA_R_Last(boolean active, boolean recommended, OrderByComparator orderByComparator)
          Returns the last s c license in the ordered set where active = ? and recommended = ?.
 SCLicense[] findByA_R_PrevAndNext(long licenseId, boolean active, boolean recommended, OrderByComparator orderByComparator)
          Returns the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?.
 List<SCLicense> findByA_R(boolean active, boolean recommended)
          Returns all the s c licenses where active = ? and recommended = ?.
 List<SCLicense> findByA_R(boolean active, boolean recommended, int start, int end)
          Returns a range of all the s c licenses where active = ? and recommended = ?.
 List<SCLicense> findByA_R(boolean active, boolean recommended, int start, int end, OrderByComparator orderByComparator)
          Returns an ordered range of all the s c licenses where active = ? and recommended = ?.
 SCLicense findByActive_First(boolean active, OrderByComparator orderByComparator)
          Returns the first s c license in the ordered set where active = ?.
 SCLicense findByActive_Last(boolean active, OrderByComparator orderByComparator)
          Returns the last s c license in the ordered set where active = ?.
 SCLicense[] findByActive_PrevAndNext(long licenseId, boolean active, OrderByComparator orderByComparator)
          Returns the s c licenses before and after the current s c license in the ordered set where active = ?.
 List<SCLicense> findByActive(boolean active)
          Returns all the s c licenses where active = ?.
 List<SCLicense> findByActive(boolean active, int start, int end)
          Returns a range of all the s c licenses where active = ?.
 List<SCLicense> findByActive(boolean active, int start, int end, OrderByComparator orderByComparator)
          Returns an ordered range of all the s c licenses where active = ?.
 SCLicense findByPrimaryKey(long licenseId)
          Returns the s c license with the primary key or throws a NoSuchLicenseException if it could not be found.
 List<SCProductEntry> getSCProductEntries(long pk)
          Returns all the s c product entries associated with the s c license.
 List<SCProductEntry> getSCProductEntries(long pk, int start, int end)
          Returns a range of all the s c product entries associated with the s c license.
 List<SCProductEntry> getSCProductEntries(long pk, int start, int end, OrderByComparator orderByComparator)
          Returns an ordered range of all the s c product entries associated with the s c license.
 int getSCProductEntriesSize(long pk)
          Returns the number of s c product entries associated with the s c license.
 SCLicense remove(long licenseId)
          Removes the s c license with the primary key from the database.
 void removeAll()
          Removes all the s c licenses from the database.
 void removeByA_R(boolean active, boolean recommended)
          Removes all the s c licenses where active = ? and recommended = ? from the database.
 void removeByActive(boolean active)
          Removes all the s c licenses where active = ? from the database.
 void removeSCProductEntries(long pk, List<SCProductEntry> scProductEntries)
          Removes the association between the s c license and the s c product entries.
 void removeSCProductEntries(long pk, long[] scProductEntryPKs)
          Removes the association between the s c license and the s c product entries.
 void removeSCProductEntry(long pk, long scProductEntryPK)
          Removes the association between the s c license and the s c product entry.
 void removeSCProductEntry(long pk, SCProductEntry scProductEntry)
          Removes the association between the s c license and the s c product entry.
 void setSCProductEntries(long pk, List<SCProductEntry> scProductEntries)
          Sets the s c product entries associated with the s c license, removing and adding associations as necessary.
 void setSCProductEntries(long pk, long[] scProductEntryPKs)
          Sets the s c product entries associated with the s c license, removing and adding associations as necessary.
 SCLicense updateImpl(SCLicense scLicense, boolean merge)
           
 
Methods inherited from interface com.liferay.portal.service.persistence.BasePersistence
clearCache, clearCache, clearCache, closeSession, countWithDynamicQuery, fetchByPrimaryKey, findByPrimaryKey, findWithDynamicQuery, findWithDynamicQuery, findWithDynamicQuery, getDataSource, getListeners, openSession, processException, registerListener, remove, remove, setDataSource, unregisterListener, update, update
 

Method Detail

cacheResult

void cacheResult(SCLicense scLicense)
Caches the s c license in the entity cache if it is enabled.

Parameters:
scLicense - the s c license

cacheResult

void cacheResult(List<SCLicense> scLicenses)
Caches the s c licenses in the entity cache if it is enabled.

Parameters:
scLicenses - the s c licenses

create

SCLicense create(long licenseId)
Creates a new s c license with the primary key. Does not add the s c license to the database.

Parameters:
licenseId - the primary key for the new s c license
Returns:
the new s c license

remove

SCLicense remove(long licenseId)
                 throws SystemException,
                        NoSuchLicenseException
Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners.

Parameters:
licenseId - the primary key of the s c license
Returns:
the s c license that was removed
Throws:
NoSuchLicenseException - if a s c license with the primary key could not be found
SystemException - if a system exception occurred

updateImpl

SCLicense updateImpl(SCLicense scLicense,
                     boolean merge)
                     throws SystemException
Throws:
SystemException

findByPrimaryKey

SCLicense findByPrimaryKey(long licenseId)
                           throws SystemException,
                                  NoSuchLicenseException
Returns the s c license with the primary key or throws a NoSuchLicenseException if it could not be found.

Parameters:
licenseId - the primary key of the s c license
Returns:
the s c license
Throws:
NoSuchLicenseException - if a s c license with the primary key could not be found
SystemException - if a system exception occurred

fetchByPrimaryKey

SCLicense fetchByPrimaryKey(long licenseId)
                            throws SystemException
Returns the s c license with the primary key or returns null if it could not be found.

Parameters:
licenseId - the primary key of the s c license
Returns:
the s c license, or null if a s c license with the primary key could not be found
Throws:
SystemException - if a system exception occurred

findByActive

List<SCLicense> findByActive(boolean active)
                             throws SystemException
Returns all the s c licenses where active = ?.

Parameters:
active - the active
Returns:
the matching s c licenses
Throws:
SystemException - if a system exception occurred

findByActive

List<SCLicense> findByActive(boolean active,
                             int start,
                             int end)
                             throws SystemException
Returns a range of all the s c licenses where active = ?.

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.

Parameters:
active - the active
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
Returns:
the range of matching s c licenses
Throws:
SystemException - if a system exception occurred

findByActive

List<SCLicense> findByActive(boolean active,
                             int start,
                             int end,
                             OrderByComparator orderByComparator)
                             throws SystemException
Returns an ordered range of all the s c licenses where active = ?.

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.

Parameters:
active - the active
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching s c licenses
Throws:
SystemException - if a system exception occurred

findByActive_First

SCLicense findByActive_First(boolean active,
                             OrderByComparator orderByComparator)
                             throws SystemException,
                                    NoSuchLicenseException
Returns the first s c license in the ordered set where active = ?.

Parameters:
active - the active
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching s c license
Throws:
NoSuchLicenseException - if a matching s c license could not be found
SystemException - if a system exception occurred

fetchByActive_First

SCLicense fetchByActive_First(boolean active,
                              OrderByComparator orderByComparator)
                              throws SystemException
Returns the first s c license in the ordered set where active = ?.

Parameters:
active - the active
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching s c license, or null if a matching s c license could not be found
Throws:
SystemException - if a system exception occurred

findByActive_Last

SCLicense findByActive_Last(boolean active,
                            OrderByComparator orderByComparator)
                            throws SystemException,
                                   NoSuchLicenseException
Returns the last s c license in the ordered set where active = ?.

Parameters:
active - the active
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching s c license
Throws:
NoSuchLicenseException - if a matching s c license could not be found
SystemException - if a system exception occurred

fetchByActive_Last

SCLicense fetchByActive_Last(boolean active,
                             OrderByComparator orderByComparator)
                             throws SystemException
Returns the last s c license in the ordered set where active = ?.

Parameters:
active - the active
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching s c license, or null if a matching s c license could not be found
Throws:
SystemException - if a system exception occurred

findByActive_PrevAndNext

SCLicense[] findByActive_PrevAndNext(long licenseId,
                                     boolean active,
                                     OrderByComparator orderByComparator)
                                     throws SystemException,
                                            NoSuchLicenseException
Returns the s c licenses before and after the current s c license in the ordered set where active = ?.

Parameters:
licenseId - the primary key of the current s c license
active - the active
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next s c license
Throws:
NoSuchLicenseException - if a s c license with the primary key could not be found
SystemException - if a system exception occurred

filterFindByActive

List<SCLicense> filterFindByActive(boolean active)
                                   throws SystemException
Returns all the s c licenses that the user has permission to view where active = ?.

Parameters:
active - the active
Returns:
the matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

filterFindByActive

List<SCLicense> filterFindByActive(boolean active,
                                   int start,
                                   int end)
                                   throws SystemException
Returns a range of all the s c licenses that the user has permission to view where active = ?.

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.

Parameters:
active - the active
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
Returns:
the range of matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

filterFindByActive

List<SCLicense> filterFindByActive(boolean active,
                                   int start,
                                   int end,
                                   OrderByComparator orderByComparator)
                                   throws SystemException
Returns an ordered range of all the s c licenses that the user has permissions to view where active = ?.

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.

Parameters:
active - the active
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

filterFindByActive_PrevAndNext

SCLicense[] filterFindByActive_PrevAndNext(long licenseId,
                                           boolean active,
                                           OrderByComparator orderByComparator)
                                           throws SystemException,
                                                  NoSuchLicenseException
Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ?.

Parameters:
licenseId - the primary key of the current s c license
active - the active
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next s c license
Throws:
NoSuchLicenseException - if a s c license with the primary key could not be found
SystemException - if a system exception occurred

findByA_R

List<SCLicense> findByA_R(boolean active,
                          boolean recommended)
                          throws SystemException
Returns all the s c licenses where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
Returns:
the matching s c licenses
Throws:
SystemException - if a system exception occurred

findByA_R

List<SCLicense> findByA_R(boolean active,
                          boolean recommended,
                          int start,
                          int end)
                          throws SystemException
Returns a range of all the s c licenses where active = ? and recommended = ?.

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.

Parameters:
active - the active
recommended - the recommended
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
Returns:
the range of matching s c licenses
Throws:
SystemException - if a system exception occurred

findByA_R

List<SCLicense> findByA_R(boolean active,
                          boolean recommended,
                          int start,
                          int end,
                          OrderByComparator orderByComparator)
                          throws SystemException
Returns an ordered range of all the s c licenses where active = ? and recommended = ?.

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.

Parameters:
active - the active
recommended - the recommended
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching s c licenses
Throws:
SystemException - if a system exception occurred

findByA_R_First

SCLicense findByA_R_First(boolean active,
                          boolean recommended,
                          OrderByComparator orderByComparator)
                          throws SystemException,
                                 NoSuchLicenseException
Returns the first s c license in the ordered set where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching s c license
Throws:
NoSuchLicenseException - if a matching s c license could not be found
SystemException - if a system exception occurred

fetchByA_R_First

SCLicense fetchByA_R_First(boolean active,
                           boolean recommended,
                           OrderByComparator orderByComparator)
                           throws SystemException
Returns the first s c license in the ordered set where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching s c license, or null if a matching s c license could not be found
Throws:
SystemException - if a system exception occurred

findByA_R_Last

SCLicense findByA_R_Last(boolean active,
                         boolean recommended,
                         OrderByComparator orderByComparator)
                         throws SystemException,
                                NoSuchLicenseException
Returns the last s c license in the ordered set where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching s c license
Throws:
NoSuchLicenseException - if a matching s c license could not be found
SystemException - if a system exception occurred

fetchByA_R_Last

SCLicense fetchByA_R_Last(boolean active,
                          boolean recommended,
                          OrderByComparator orderByComparator)
                          throws SystemException
Returns the last s c license in the ordered set where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching s c license, or null if a matching s c license could not be found
Throws:
SystemException - if a system exception occurred

findByA_R_PrevAndNext

SCLicense[] findByA_R_PrevAndNext(long licenseId,
                                  boolean active,
                                  boolean recommended,
                                  OrderByComparator orderByComparator)
                                  throws SystemException,
                                         NoSuchLicenseException
Returns the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?.

Parameters:
licenseId - the primary key of the current s c license
active - the active
recommended - the recommended
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next s c license
Throws:
NoSuchLicenseException - if a s c license with the primary key could not be found
SystemException - if a system exception occurred

filterFindByA_R

List<SCLicense> filterFindByA_R(boolean active,
                                boolean recommended)
                                throws SystemException
Returns all the s c licenses that the user has permission to view where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
Returns:
the matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

filterFindByA_R

List<SCLicense> filterFindByA_R(boolean active,
                                boolean recommended,
                                int start,
                                int end)
                                throws SystemException
Returns a range of all the s c licenses that the user has permission to view where active = ? and recommended = ?.

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.

Parameters:
active - the active
recommended - the recommended
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
Returns:
the range of matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

filterFindByA_R

List<SCLicense> filterFindByA_R(boolean active,
                                boolean recommended,
                                int start,
                                int end,
                                OrderByComparator orderByComparator)
                                throws SystemException
Returns an ordered range of all the s c licenses that the user has permissions to view where active = ? and recommended = ?.

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.

Parameters:
active - the active
recommended - the recommended
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

filterFindByA_R_PrevAndNext

SCLicense[] filterFindByA_R_PrevAndNext(long licenseId,
                                        boolean active,
                                        boolean recommended,
                                        OrderByComparator orderByComparator)
                                        throws SystemException,
                                               NoSuchLicenseException
Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ? and recommended = ?.

Parameters:
licenseId - the primary key of the current s c license
active - the active
recommended - the recommended
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next s c license
Throws:
NoSuchLicenseException - if a s c license with the primary key could not be found
SystemException - if a system exception occurred

findAll

List<SCLicense> findAll()
                        throws SystemException
Returns all the s c licenses.

Returns:
the s c licenses
Throws:
SystemException - if a system exception occurred

findAll

List<SCLicense> findAll(int start,
                        int end)
                        throws SystemException
Returns a range of all the s c licenses.

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.

Parameters:
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
Returns:
the range of s c licenses
Throws:
SystemException - if a system exception occurred

findAll

List<SCLicense> findAll(int start,
                        int end,
                        OrderByComparator orderByComparator)
                        throws SystemException
Returns an ordered range of all the s c licenses.

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.

Parameters:
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of s c licenses
Throws:
SystemException - if a system exception occurred

removeByActive

void removeByActive(boolean active)
                    throws SystemException
Removes all the s c licenses where active = ? from the database.

Parameters:
active - the active
Throws:
SystemException - if a system exception occurred

removeByA_R

void removeByA_R(boolean active,
                 boolean recommended)
                 throws SystemException
Removes all the s c licenses where active = ? and recommended = ? from the database.

Parameters:
active - the active
recommended - the recommended
Throws:
SystemException - if a system exception occurred

removeAll

void removeAll()
               throws SystemException
Removes all the s c licenses from the database.

Throws:
SystemException - if a system exception occurred

countByActive

int countByActive(boolean active)
                  throws SystemException
Returns the number of s c licenses where active = ?.

Parameters:
active - the active
Returns:
the number of matching s c licenses
Throws:
SystemException - if a system exception occurred

filterCountByActive

int filterCountByActive(boolean active)
                        throws SystemException
Returns the number of s c licenses that the user has permission to view where active = ?.

Parameters:
active - the active
Returns:
the number of matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

countByA_R

int countByA_R(boolean active,
               boolean recommended)
               throws SystemException
Returns the number of s c licenses where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
Returns:
the number of matching s c licenses
Throws:
SystemException - if a system exception occurred

filterCountByA_R

int filterCountByA_R(boolean active,
                     boolean recommended)
                     throws SystemException
Returns the number of s c licenses that the user has permission to view where active = ? and recommended = ?.

Parameters:
active - the active
recommended - the recommended
Returns:
the number of matching s c licenses that the user has permission to view
Throws:
SystemException - if a system exception occurred

countAll

int countAll()
             throws SystemException
Returns the number of s c licenses.

Returns:
the number of s c licenses
Throws:
SystemException - if a system exception occurred

getSCProductEntries

List<SCProductEntry> getSCProductEntries(long pk)
                                         throws SystemException
Returns all the s c product entries associated with the s c license.

Parameters:
pk - the primary key of the s c license
Returns:
the s c product entries associated with the s c license
Throws:
SystemException - if a system exception occurred

getSCProductEntries

List<SCProductEntry> getSCProductEntries(long pk,
                                         int start,
                                         int end)
                                         throws SystemException
Returns a range of all the s c product entries associated with the s c license.

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.

Parameters:
pk - the primary key of the s c license
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
Returns:
the range of s c product entries associated with the s c license
Throws:
SystemException - if a system exception occurred

getSCProductEntries

List<SCProductEntry> getSCProductEntries(long pk,
                                         int start,
                                         int end,
                                         OrderByComparator orderByComparator)
                                         throws SystemException
Returns an ordered range of all the s c product entries associated with the s c license.

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.

Parameters:
pk - the primary key of the s c license
start - the lower bound of the range of s c licenses
end - the upper bound of the range of s c licenses (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of s c product entries associated with the s c license
Throws:
SystemException - if a system exception occurred

getSCProductEntriesSize

int getSCProductEntriesSize(long pk)
                            throws SystemException
Returns the number of s c product entries associated with the s c license.

Parameters:
pk - the primary key of the s c license
Returns:
the number of s c product entries associated with the s c license
Throws:
SystemException - if a system exception occurred

containsSCProductEntry

boolean containsSCProductEntry(long pk,
                               long scProductEntryPK)
                               throws SystemException
Returns true if the s c product entry is associated with the s c license.

Parameters:
pk - the primary key of the s c license
scProductEntryPK - the primary key of the s c product entry
Returns:
true if the s c product entry is associated with the s c license; false otherwise
Throws:
SystemException - if a system exception occurred

containsSCProductEntries

boolean containsSCProductEntries(long pk)
                                 throws SystemException
Returns true if the s c license has any s c product entries associated with it.

Parameters:
pk - the primary key of the s c license to check for associations with s c product entries
Returns:
true if the s c license has any s c product entries associated with it; false otherwise
Throws:
SystemException - if a system exception occurred

addSCProductEntry

void addSCProductEntry(long pk,
                       long scProductEntryPK)
                       throws SystemException
Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntryPK - the primary key of the s c product entry
Throws:
SystemException - if a system exception occurred

addSCProductEntry

void addSCProductEntry(long pk,
                       SCProductEntry scProductEntry)
                       throws SystemException
Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntry - the s c product entry
Throws:
SystemException - if a system exception occurred

addSCProductEntries

void addSCProductEntries(long pk,
                         long[] scProductEntryPKs)
                         throws SystemException
Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntryPKs - the primary keys of the s c product entries
Throws:
SystemException - if a system exception occurred

addSCProductEntries

void addSCProductEntries(long pk,
                         List<SCProductEntry> scProductEntries)
                         throws SystemException
Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntries - the s c product entries
Throws:
SystemException - if a system exception occurred

clearSCProductEntries

void clearSCProductEntries(long pk)
                           throws SystemException
Clears all associations between the s c license and its s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license to clear the associated s c product entries from
Throws:
SystemException - if a system exception occurred

removeSCProductEntry

void removeSCProductEntry(long pk,
                          long scProductEntryPK)
                          throws SystemException
Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntryPK - the primary key of the s c product entry
Throws:
SystemException - if a system exception occurred

removeSCProductEntry

void removeSCProductEntry(long pk,
                          SCProductEntry scProductEntry)
                          throws SystemException
Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntry - the s c product entry
Throws:
SystemException - if a system exception occurred

removeSCProductEntries

void removeSCProductEntries(long pk,
                            long[] scProductEntryPKs)
                            throws SystemException
Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntryPKs - the primary keys of the s c product entries
Throws:
SystemException - if a system exception occurred

removeSCProductEntries

void removeSCProductEntries(long pk,
                            List<SCProductEntry> scProductEntries)
                            throws SystemException
Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntries - the s c product entries
Throws:
SystemException - if a system exception occurred

setSCProductEntries

void setSCProductEntries(long pk,
                         long[] scProductEntryPKs)
                         throws SystemException
Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntryPKs - the primary keys of the s c product entries to be associated with the s c license
Throws:
SystemException - if a system exception occurred

setSCProductEntries

void setSCProductEntries(long pk,
                         List<SCProductEntry> scProductEntries)
                         throws SystemException
Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the s c license
scProductEntries - the s c product entries to be associated with the s c license
Throws:
SystemException - if a system exception occurred

Liferay 6.1.2-ce-ga3