Java tutorial
/** * Copyright (c) 2000-present Liferay, Inc. All rights reserved. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 2.1 of the License, or (at your option) * any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. */ package ca.efendi.datafeeds.service.persistence.impl; import aQute.bnd.annotation.ProviderType; import ca.efendi.datafeeds.exception.NoSuchFtpSubscriptionException; import ca.efendi.datafeeds.model.FtpSubscription; import ca.efendi.datafeeds.model.impl.FtpSubscriptionImpl; import ca.efendi.datafeeds.model.impl.FtpSubscriptionModelImpl; import ca.efendi.datafeeds.service.persistence.FtpSubscriptionPersistence; import com.liferay.portal.kernel.dao.orm.EntityCache; import com.liferay.portal.kernel.dao.orm.FinderCache; import com.liferay.portal.kernel.dao.orm.FinderPath; import com.liferay.portal.kernel.dao.orm.Query; import com.liferay.portal.kernel.dao.orm.QueryPos; import com.liferay.portal.kernel.dao.orm.QueryUtil; import com.liferay.portal.kernel.dao.orm.Session; import com.liferay.portal.kernel.log.Log; import com.liferay.portal.kernel.log.LogFactoryUtil; import com.liferay.portal.kernel.service.ServiceContext; import com.liferay.portal.kernel.service.ServiceContextThreadLocal; import com.liferay.portal.kernel.service.persistence.CompanyProvider; import com.liferay.portal.kernel.service.persistence.CompanyProviderWrapper; import com.liferay.portal.kernel.service.persistence.impl.BasePersistenceImpl; import com.liferay.portal.kernel.util.OrderByComparator; import com.liferay.portal.kernel.util.StringBundler; import com.liferay.portal.kernel.util.StringPool; import com.liferay.portal.spring.extender.service.ServiceReference; import java.io.Serializable; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; /** * The persistence implementation for the ftp subscription service. * * <p> * Caching information and settings can be found in <code>portal.properties</code> * </p> * * @author Brian Wing Shun Chan * @see FtpSubscriptionPersistence * @see ca.efendi.datafeeds.service.persistence.FtpSubscriptionUtil * @generated */ @ProviderType public class FtpSubscriptionPersistenceImpl extends BasePersistenceImpl<FtpSubscription> implements FtpSubscriptionPersistence { /* * NOTE FOR DEVELOPERS: * * Never modify or reference this class directly. Always use {@link FtpSubscriptionUtil} to access the ftp subscription persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. */ public static final String FINDER_CLASS_NAME_ENTITY = FtpSubscriptionImpl.class.getName(); public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY + ".List1"; public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY + ".List2"; public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath( FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionModelImpl.FINDER_CACHE_ENABLED, FtpSubscriptionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]); public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath( FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionModelImpl.FINDER_CACHE_ENABLED, FtpSubscriptionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]); public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath( FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]); public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath( FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionModelImpl.FINDER_CACHE_ENABLED, FtpSubscriptionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId", new String[] { Long.class.getName(), Integer.class.getName(), Integer.class.getName(), OrderByComparator.class.getName() }); public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID = new FinderPath( FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionModelImpl.FINDER_CACHE_ENABLED, FtpSubscriptionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId", new String[] { Long.class.getName() }, FtpSubscriptionModelImpl.GROUPID_COLUMN_BITMASK); public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath( FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId", new String[] { Long.class.getName() }); /** * Returns all the ftp subscriptions where groupId = ?. * * @param groupId the group ID * @return the matching ftp subscriptions */ @Override public List<FtpSubscription> findByGroupId(long groupId) { return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null); } /** * Returns a range of all the ftp subscriptions where groupId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link FtpSubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param groupId the group ID * @param start the lower bound of the range of ftp subscriptions * @param end the upper bound of the range of ftp subscriptions (not inclusive) * @return the range of matching ftp subscriptions */ @Override public List<FtpSubscription> findByGroupId(long groupId, int start, int end) { return findByGroupId(groupId, start, end, null); } /** * Returns an ordered range of all the ftp subscriptions where groupId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link FtpSubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param groupId the group ID * @param start the lower bound of the range of ftp subscriptions * @param end the upper bound of the range of ftp subscriptions (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @return the ordered range of matching ftp subscriptions */ @Override public List<FtpSubscription> findByGroupId(long groupId, int start, int end, OrderByComparator<FtpSubscription> orderByComparator) { return findByGroupId(groupId, start, end, orderByComparator, true); } /** * Returns an ordered range of all the ftp subscriptions where groupId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link FtpSubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param groupId the group ID * @param start the lower bound of the range of ftp subscriptions * @param end the upper bound of the range of ftp subscriptions (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @param retrieveFromCache whether to retrieve from the finder cache * @return the ordered range of matching ftp subscriptions */ @Override public List<FtpSubscription> findByGroupId(long groupId, int start, int end, OrderByComparator<FtpSubscription> orderByComparator, boolean retrieveFromCache) { boolean pagination = true; FinderPath finderPath = null; Object[] finderArgs = null; if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) { pagination = false; finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID; finderArgs = new Object[] { groupId }; } else { finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID; finderArgs = new Object[] { groupId, start, end, orderByComparator }; } List<FtpSubscription> list = null; if (retrieveFromCache) { list = (List<FtpSubscription>) finderCache.getResult(finderPath, finderArgs, this); if ((list != null) && !list.isEmpty()) { for (FtpSubscription ftpSubscription : list) { if ((groupId != ftpSubscription.getGroupId())) { list = null; break; } } } } if (list == null) { StringBundler query = null; if (orderByComparator != null) { query = new StringBundler(3 + (orderByComparator.getOrderByFields().length * 2)); } else { query = new StringBundler(3); } query.append(_SQL_SELECT_FTPSUBSCRIPTION_WHERE); query.append(_FINDER_COLUMN_GROUPID_GROUPID_2); if (orderByComparator != null) { appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator); } else if (pagination) { query.append(FtpSubscriptionModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); qPos.add(groupId); if (!pagination) { list = (List<FtpSubscription>) QueryUtil.list(q, getDialect(), start, end, false); Collections.sort(list); list = Collections.unmodifiableList(list); } else { list = (List<FtpSubscription>) QueryUtil.list(q, getDialect(), start, end); } cacheResult(list); finderCache.putResult(finderPath, finderArgs, list); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return list; } /** * Returns the first ftp subscription in the ordered set where groupId = ?. * * @param groupId the group ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the first matching ftp subscription * @throws NoSuchFtpSubscriptionException if a matching ftp subscription could not be found */ @Override public FtpSubscription findByGroupId_First(long groupId, OrderByComparator<FtpSubscription> orderByComparator) throws NoSuchFtpSubscriptionException { FtpSubscription ftpSubscription = fetchByGroupId_First(groupId, orderByComparator); if (ftpSubscription != null) { return ftpSubscription; } StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("groupId="); msg.append(groupId); msg.append(StringPool.CLOSE_CURLY_BRACE); throw new NoSuchFtpSubscriptionException(msg.toString()); } /** * Returns the first ftp subscription in the ordered set where groupId = ?. * * @param groupId the group ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the first matching ftp subscription, or <code>null</code> if a matching ftp subscription could not be found */ @Override public FtpSubscription fetchByGroupId_First(long groupId, OrderByComparator<FtpSubscription> orderByComparator) { List<FtpSubscription> list = findByGroupId(groupId, 0, 1, orderByComparator); if (!list.isEmpty()) { return list.get(0); } return null; } /** * Returns the last ftp subscription in the ordered set where groupId = ?. * * @param groupId the group ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the last matching ftp subscription * @throws NoSuchFtpSubscriptionException if a matching ftp subscription could not be found */ @Override public FtpSubscription findByGroupId_Last(long groupId, OrderByComparator<FtpSubscription> orderByComparator) throws NoSuchFtpSubscriptionException { FtpSubscription ftpSubscription = fetchByGroupId_Last(groupId, orderByComparator); if (ftpSubscription != null) { return ftpSubscription; } StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("groupId="); msg.append(groupId); msg.append(StringPool.CLOSE_CURLY_BRACE); throw new NoSuchFtpSubscriptionException(msg.toString()); } /** * Returns the last ftp subscription in the ordered set where groupId = ?. * * @param groupId the group ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the last matching ftp subscription, or <code>null</code> if a matching ftp subscription could not be found */ @Override public FtpSubscription fetchByGroupId_Last(long groupId, OrderByComparator<FtpSubscription> orderByComparator) { int count = countByGroupId(groupId); if (count == 0) { return null; } List<FtpSubscription> list = findByGroupId(groupId, count - 1, count, orderByComparator); if (!list.isEmpty()) { return list.get(0); } return null; } /** * Returns the ftp subscriptions before and after the current ftp subscription in the ordered set where groupId = ?. * * @param ftpSubscriptionId the primary key of the current ftp subscription * @param groupId the group ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the previous, current, and next ftp subscription * @throws NoSuchFtpSubscriptionException if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription[] findByGroupId_PrevAndNext(long ftpSubscriptionId, long groupId, OrderByComparator<FtpSubscription> orderByComparator) throws NoSuchFtpSubscriptionException { FtpSubscription ftpSubscription = findByPrimaryKey(ftpSubscriptionId); Session session = null; try { session = openSession(); FtpSubscription[] array = new FtpSubscriptionImpl[3]; array[0] = getByGroupId_PrevAndNext(session, ftpSubscription, groupId, orderByComparator, true); array[1] = ftpSubscription; array[2] = getByGroupId_PrevAndNext(session, ftpSubscription, groupId, orderByComparator, false); return array; } catch (Exception e) { throw processException(e); } finally { closeSession(session); } } protected FtpSubscription getByGroupId_PrevAndNext(Session session, FtpSubscription ftpSubscription, long groupId, OrderByComparator<FtpSubscription> orderByComparator, boolean previous) { StringBundler query = null; if (orderByComparator != null) { query = new StringBundler(4 + (orderByComparator.getOrderByConditionFields().length * 3) + (orderByComparator.getOrderByFields().length * 3)); } else { query = new StringBundler(3); } query.append(_SQL_SELECT_FTPSUBSCRIPTION_WHERE); query.append(_FINDER_COLUMN_GROUPID_GROUPID_2); if (orderByComparator != null) { String[] orderByConditionFields = orderByComparator.getOrderByConditionFields(); if (orderByConditionFields.length > 0) { query.append(WHERE_AND); } for (int i = 0; i < orderByConditionFields.length; i++) { query.append(_ORDER_BY_ENTITY_ALIAS); query.append(orderByConditionFields[i]); if ((i + 1) < orderByConditionFields.length) { if (orderByComparator.isAscending() ^ previous) { query.append(WHERE_GREATER_THAN_HAS_NEXT); } else { query.append(WHERE_LESSER_THAN_HAS_NEXT); } } else { if (orderByComparator.isAscending() ^ previous) { query.append(WHERE_GREATER_THAN); } else { query.append(WHERE_LESSER_THAN); } } } query.append(ORDER_BY_CLAUSE); String[] orderByFields = orderByComparator.getOrderByFields(); for (int i = 0; i < orderByFields.length; i++) { query.append(_ORDER_BY_ENTITY_ALIAS); query.append(orderByFields[i]); if ((i + 1) < orderByFields.length) { if (orderByComparator.isAscending() ^ previous) { query.append(ORDER_BY_ASC_HAS_NEXT); } else { query.append(ORDER_BY_DESC_HAS_NEXT); } } else { if (orderByComparator.isAscending() ^ previous) { query.append(ORDER_BY_ASC); } else { query.append(ORDER_BY_DESC); } } } } else { query.append(FtpSubscriptionModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Query q = session.createQuery(sql); q.setFirstResult(0); q.setMaxResults(2); QueryPos qPos = QueryPos.getInstance(q); qPos.add(groupId); if (orderByComparator != null) { Object[] values = orderByComparator.getOrderByConditionValues(ftpSubscription); for (Object value : values) { qPos.add(value); } } List<FtpSubscription> list = q.list(); if (list.size() == 2) { return list.get(1); } else { return null; } } /** * Removes all the ftp subscriptions where groupId = ? from the database. * * @param groupId the group ID */ @Override public void removeByGroupId(long groupId) { for (FtpSubscription ftpSubscription : findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) { remove(ftpSubscription); } } /** * Returns the number of ftp subscriptions where groupId = ?. * * @param groupId the group ID * @return the number of matching ftp subscriptions */ @Override public int countByGroupId(long groupId) { FinderPath finderPath = FINDER_PATH_COUNT_BY_GROUPID; Object[] finderArgs = new Object[] { groupId }; Long count = (Long) finderCache.getResult(finderPath, finderArgs, this); if (count == null) { StringBundler query = new StringBundler(2); query.append(_SQL_COUNT_FTPSUBSCRIPTION_WHERE); query.append(_FINDER_COLUMN_GROUPID_GROUPID_2); String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); qPos.add(groupId); count = (Long) q.uniqueResult(); finderCache.putResult(finderPath, finderArgs, count); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "ftpSubscription.groupId = ?"; public FtpSubscriptionPersistenceImpl() { setModelClass(FtpSubscription.class); } /** * Caches the ftp subscription in the entity cache if it is enabled. * * @param ftpSubscription the ftp subscription */ @Override public void cacheResult(FtpSubscription ftpSubscription) { entityCache.putResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, ftpSubscription.getPrimaryKey(), ftpSubscription); ftpSubscription.resetOriginalValues(); } /** * Caches the ftp subscriptions in the entity cache if it is enabled. * * @param ftpSubscriptions the ftp subscriptions */ @Override public void cacheResult(List<FtpSubscription> ftpSubscriptions) { for (FtpSubscription ftpSubscription : ftpSubscriptions) { if (entityCache.getResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, ftpSubscription.getPrimaryKey()) == null) { cacheResult(ftpSubscription); } else { ftpSubscription.resetOriginalValues(); } } } /** * Clears the cache for all ftp subscriptions. * * <p> * The {@link EntityCache} and {@link FinderCache} are both cleared by this method. * </p> */ @Override public void clearCache() { entityCache.clearCache(FtpSubscriptionImpl.class); finderCache.clearCache(FINDER_CLASS_NAME_ENTITY); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } /** * Clears the cache for the ftp subscription. * * <p> * The {@link EntityCache} and {@link FinderCache} are both cleared by this method. * </p> */ @Override public void clearCache(FtpSubscription ftpSubscription) { entityCache.removeResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, ftpSubscription.getPrimaryKey()); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } @Override public void clearCache(List<FtpSubscription> ftpSubscriptions) { finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); for (FtpSubscription ftpSubscription : ftpSubscriptions) { entityCache.removeResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, ftpSubscription.getPrimaryKey()); } } /** * Creates a new ftp subscription with the primary key. Does not add the ftp subscription to the database. * * @param ftpSubscriptionId the primary key for the new ftp subscription * @return the new ftp subscription */ @Override public FtpSubscription create(long ftpSubscriptionId) { FtpSubscription ftpSubscription = new FtpSubscriptionImpl(); ftpSubscription.setNew(true); ftpSubscription.setPrimaryKey(ftpSubscriptionId); ftpSubscription.setCompanyId(companyProvider.getCompanyId()); return ftpSubscription; } /** * Removes the ftp subscription with the primary key from the database. Also notifies the appropriate model listeners. * * @param ftpSubscriptionId the primary key of the ftp subscription * @return the ftp subscription that was removed * @throws NoSuchFtpSubscriptionException if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription remove(long ftpSubscriptionId) throws NoSuchFtpSubscriptionException { return remove((Serializable) ftpSubscriptionId); } /** * Removes the ftp subscription with the primary key from the database. Also notifies the appropriate model listeners. * * @param primaryKey the primary key of the ftp subscription * @return the ftp subscription that was removed * @throws NoSuchFtpSubscriptionException if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription remove(Serializable primaryKey) throws NoSuchFtpSubscriptionException { Session session = null; try { session = openSession(); FtpSubscription ftpSubscription = (FtpSubscription) session.get(FtpSubscriptionImpl.class, primaryKey); if (ftpSubscription == null) { if (_log.isDebugEnabled()) { _log.debug(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } throw new NoSuchFtpSubscriptionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } return remove(ftpSubscription); } catch (NoSuchFtpSubscriptionException nsee) { throw nsee; } catch (Exception e) { throw processException(e); } finally { closeSession(session); } } @Override protected FtpSubscription removeImpl(FtpSubscription ftpSubscription) { ftpSubscription = toUnwrappedModel(ftpSubscription); Session session = null; try { session = openSession(); if (!session.contains(ftpSubscription)) { ftpSubscription = (FtpSubscription) session.get(FtpSubscriptionImpl.class, ftpSubscription.getPrimaryKeyObj()); } if (ftpSubscription != null) { session.delete(ftpSubscription); } } catch (Exception e) { throw processException(e); } finally { closeSession(session); } if (ftpSubscription != null) { clearCache(ftpSubscription); } return ftpSubscription; } @Override public FtpSubscription updateImpl(FtpSubscription ftpSubscription) { ftpSubscription = toUnwrappedModel(ftpSubscription); boolean isNew = ftpSubscription.isNew(); FtpSubscriptionModelImpl ftpSubscriptionModelImpl = (FtpSubscriptionModelImpl) ftpSubscription; ServiceContext serviceContext = ServiceContextThreadLocal.getServiceContext(); Date now = new Date(); if (isNew && (ftpSubscription.getCreateDate() == null)) { if (serviceContext == null) { ftpSubscription.setCreateDate(now); } else { ftpSubscription.setCreateDate(serviceContext.getCreateDate(now)); } } if (!ftpSubscriptionModelImpl.hasSetModifiedDate()) { if (serviceContext == null) { ftpSubscription.setModifiedDate(now); } else { ftpSubscription.setModifiedDate(serviceContext.getModifiedDate(now)); } } Session session = null; try { session = openSession(); if (ftpSubscription.isNew()) { session.save(ftpSubscription); ftpSubscription.setNew(false); } else { ftpSubscription = (FtpSubscription) session.merge(ftpSubscription); } } catch (Exception e) { throw processException(e); } finally { closeSession(session); } finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); if (isNew || !FtpSubscriptionModelImpl.COLUMN_BITMASK_ENABLED) { finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } else { if ((ftpSubscriptionModelImpl.getColumnBitmask() & FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) { Object[] args = new Object[] { ftpSubscriptionModelImpl.getOriginalGroupId() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args); finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID, args); args = new Object[] { ftpSubscriptionModelImpl.getGroupId() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args); finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID, args); } } entityCache.putResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, ftpSubscription.getPrimaryKey(), ftpSubscription, false); ftpSubscription.resetOriginalValues(); return ftpSubscription; } protected FtpSubscription toUnwrappedModel(FtpSubscription ftpSubscription) { if (ftpSubscription instanceof FtpSubscriptionImpl) { return ftpSubscription; } FtpSubscriptionImpl ftpSubscriptionImpl = new FtpSubscriptionImpl(); ftpSubscriptionImpl.setNew(ftpSubscription.isNew()); ftpSubscriptionImpl.setPrimaryKey(ftpSubscription.getPrimaryKey()); ftpSubscriptionImpl.setFtpSubscriptionId(ftpSubscription.getFtpSubscriptionId()); ftpSubscriptionImpl.setGroupId(ftpSubscription.getGroupId()); ftpSubscriptionImpl.setCompanyId(ftpSubscription.getCompanyId()); ftpSubscriptionImpl.setUserId(ftpSubscription.getUserId()); ftpSubscriptionImpl.setUserName(ftpSubscription.getUserName()); ftpSubscriptionImpl.setCreateDate(ftpSubscription.getCreateDate()); ftpSubscriptionImpl.setModifiedDate(ftpSubscription.getModifiedDate()); ftpSubscriptionImpl.setFtpHost(ftpSubscription.getFtpHost()); ftpSubscriptionImpl.setFtpUser(ftpSubscription.getFtpUser()); ftpSubscriptionImpl.setFtpPassword(ftpSubscription.getFtpPassword()); ftpSubscriptionImpl.setFtpFolder(ftpSubscription.getFtpFolder()); ftpSubscriptionImpl.setFtpFile(ftpSubscription.getFtpFile()); ftpSubscriptionImpl.setFtpDatafeedName(ftpSubscription.getFtpDatafeedName()); ftpSubscriptionImpl.setFtpDatafeedDescription(ftpSubscription.getFtpDatafeedDescription()); return ftpSubscriptionImpl; } /** * Returns the ftp subscription with the primary key or throws a {@link com.liferay.portal.kernel.exception.NoSuchModelException} if it could not be found. * * @param primaryKey the primary key of the ftp subscription * @return the ftp subscription * @throws NoSuchFtpSubscriptionException if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription findByPrimaryKey(Serializable primaryKey) throws NoSuchFtpSubscriptionException { FtpSubscription ftpSubscription = fetchByPrimaryKey(primaryKey); if (ftpSubscription == null) { if (_log.isDebugEnabled()) { _log.debug(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } throw new NoSuchFtpSubscriptionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } return ftpSubscription; } /** * Returns the ftp subscription with the primary key or throws a {@link NoSuchFtpSubscriptionException} if it could not be found. * * @param ftpSubscriptionId the primary key of the ftp subscription * @return the ftp subscription * @throws NoSuchFtpSubscriptionException if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription findByPrimaryKey(long ftpSubscriptionId) throws NoSuchFtpSubscriptionException { return findByPrimaryKey((Serializable) ftpSubscriptionId); } /** * Returns the ftp subscription with the primary key or returns <code>null</code> if it could not be found. * * @param primaryKey the primary key of the ftp subscription * @return the ftp subscription, or <code>null</code> if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription fetchByPrimaryKey(Serializable primaryKey) { Serializable serializable = entityCache.getResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, primaryKey); if (serializable == nullModel) { return null; } FtpSubscription ftpSubscription = (FtpSubscription) serializable; if (ftpSubscription == null) { Session session = null; try { session = openSession(); ftpSubscription = (FtpSubscription) session.get(FtpSubscriptionImpl.class, primaryKey); if (ftpSubscription != null) { cacheResult(ftpSubscription); } else { entityCache.putResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, primaryKey, nullModel); } } catch (Exception e) { entityCache.removeResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, primaryKey); throw processException(e); } finally { closeSession(session); } } return ftpSubscription; } /** * Returns the ftp subscription with the primary key or returns <code>null</code> if it could not be found. * * @param ftpSubscriptionId the primary key of the ftp subscription * @return the ftp subscription, or <code>null</code> if a ftp subscription with the primary key could not be found */ @Override public FtpSubscription fetchByPrimaryKey(long ftpSubscriptionId) { return fetchByPrimaryKey((Serializable) ftpSubscriptionId); } @Override public Map<Serializable, FtpSubscription> fetchByPrimaryKeys(Set<Serializable> primaryKeys) { if (primaryKeys.isEmpty()) { return Collections.emptyMap(); } Map<Serializable, FtpSubscription> map = new HashMap<Serializable, FtpSubscription>(); if (primaryKeys.size() == 1) { Iterator<Serializable> iterator = primaryKeys.iterator(); Serializable primaryKey = iterator.next(); FtpSubscription ftpSubscription = fetchByPrimaryKey(primaryKey); if (ftpSubscription != null) { map.put(primaryKey, ftpSubscription); } return map; } Set<Serializable> uncachedPrimaryKeys = null; for (Serializable primaryKey : primaryKeys) { Serializable serializable = entityCache.getResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, primaryKey); if (serializable != nullModel) { if (serializable == null) { if (uncachedPrimaryKeys == null) { uncachedPrimaryKeys = new HashSet<Serializable>(); } uncachedPrimaryKeys.add(primaryKey); } else { map.put(primaryKey, (FtpSubscription) serializable); } } } if (uncachedPrimaryKeys == null) { return map; } StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) + 1); query.append(_SQL_SELECT_FTPSUBSCRIPTION_WHERE_PKS_IN); for (Serializable primaryKey : uncachedPrimaryKeys) { query.append(String.valueOf(primaryKey)); query.append(StringPool.COMMA); } query.setIndex(query.index() - 1); query.append(StringPool.CLOSE_PARENTHESIS); String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); for (FtpSubscription ftpSubscription : (List<FtpSubscription>) q.list()) { map.put(ftpSubscription.getPrimaryKeyObj(), ftpSubscription); cacheResult(ftpSubscription); uncachedPrimaryKeys.remove(ftpSubscription.getPrimaryKeyObj()); } for (Serializable primaryKey : uncachedPrimaryKeys) { entityCache.putResult(FtpSubscriptionModelImpl.ENTITY_CACHE_ENABLED, FtpSubscriptionImpl.class, primaryKey, nullModel); } } catch (Exception e) { throw processException(e); } finally { closeSession(session); } return map; } /** * Returns all the ftp subscriptions. * * @return the ftp subscriptions */ @Override public List<FtpSubscription> findAll() { return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null); } /** * Returns a range of all the ftp subscriptions. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link FtpSubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param start the lower bound of the range of ftp subscriptions * @param end the upper bound of the range of ftp subscriptions (not inclusive) * @return the range of ftp subscriptions */ @Override public List<FtpSubscription> findAll(int start, int end) { return findAll(start, end, null); } /** * Returns an ordered range of all the ftp subscriptions. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link FtpSubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param start the lower bound of the range of ftp subscriptions * @param end the upper bound of the range of ftp subscriptions (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @return the ordered range of ftp subscriptions */ @Override public List<FtpSubscription> findAll(int start, int end, OrderByComparator<FtpSubscription> orderByComparator) { return findAll(start, end, orderByComparator, true); } /** * Returns an ordered range of all the ftp subscriptions. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link FtpSubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param start the lower bound of the range of ftp subscriptions * @param end the upper bound of the range of ftp subscriptions (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @param retrieveFromCache whether to retrieve from the finder cache * @return the ordered range of ftp subscriptions */ @Override public List<FtpSubscription> findAll(int start, int end, OrderByComparator<FtpSubscription> orderByComparator, boolean retrieveFromCache) { boolean pagination = true; FinderPath finderPath = null; Object[] finderArgs = null; if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) { pagination = false; finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL; finderArgs = FINDER_ARGS_EMPTY; } else { finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL; finderArgs = new Object[] { start, end, orderByComparator }; } List<FtpSubscription> list = null; if (retrieveFromCache) { list = (List<FtpSubscription>) finderCache.getResult(finderPath, finderArgs, this); } if (list == null) { StringBundler query = null; String sql = null; if (orderByComparator != null) { query = new StringBundler(2 + (orderByComparator.getOrderByFields().length * 2)); query.append(_SQL_SELECT_FTPSUBSCRIPTION); appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator); sql = query.toString(); } else { sql = _SQL_SELECT_FTPSUBSCRIPTION; if (pagination) { sql = sql.concat(FtpSubscriptionModelImpl.ORDER_BY_JPQL); } } Session session = null; try { session = openSession(); Query q = session.createQuery(sql); if (!pagination) { list = (List<FtpSubscription>) QueryUtil.list(q, getDialect(), start, end, false); Collections.sort(list); list = Collections.unmodifiableList(list); } else { list = (List<FtpSubscription>) QueryUtil.list(q, getDialect(), start, end); } cacheResult(list); finderCache.putResult(finderPath, finderArgs, list); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return list; } /** * Removes all the ftp subscriptions from the database. * */ @Override public void removeAll() { for (FtpSubscription ftpSubscription : findAll()) { remove(ftpSubscription); } } /** * Returns the number of ftp subscriptions. * * @return the number of ftp subscriptions */ @Override public int countAll() { Long count = (Long) finderCache.getResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY, this); if (count == null) { Session session = null; try { session = openSession(); Query q = session.createQuery(_SQL_COUNT_FTPSUBSCRIPTION); count = (Long) q.uniqueResult(); finderCache.putResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY, count); } catch (Exception e) { finderCache.removeResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } @Override protected Map<String, Integer> getTableColumnsMap() { return FtpSubscriptionModelImpl.TABLE_COLUMNS_MAP; } /** * Initializes the ftp subscription persistence. */ public void afterPropertiesSet() { } public void destroy() { entityCache.removeCache(FtpSubscriptionImpl.class.getName()); finderCache.removeCache(FINDER_CLASS_NAME_ENTITY); finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } @ServiceReference(type = CompanyProviderWrapper.class) protected CompanyProvider companyProvider; @ServiceReference(type = EntityCache.class) protected EntityCache entityCache; @ServiceReference(type = FinderCache.class) protected FinderCache finderCache; private static final String _SQL_SELECT_FTPSUBSCRIPTION = "SELECT ftpSubscription FROM FtpSubscription ftpSubscription"; private static final String _SQL_SELECT_FTPSUBSCRIPTION_WHERE_PKS_IN = "SELECT ftpSubscription FROM FtpSubscription ftpSubscription WHERE ftpSubscriptionId IN ("; private static final String _SQL_SELECT_FTPSUBSCRIPTION_WHERE = "SELECT ftpSubscription FROM FtpSubscription ftpSubscription WHERE "; private static final String _SQL_COUNT_FTPSUBSCRIPTION = "SELECT COUNT(ftpSubscription) FROM FtpSubscription ftpSubscription"; private static final String _SQL_COUNT_FTPSUBSCRIPTION_WHERE = "SELECT COUNT(ftpSubscription) FROM FtpSubscription ftpSubscription WHERE "; private static final String _ORDER_BY_ENTITY_ALIAS = "ftpSubscription."; private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No FtpSubscription exists with the primary key "; private static final String _NO_SUCH_ENTITY_WITH_KEY = "No FtpSubscription exists with the key {"; private static final Log _log = LogFactoryUtil.getLog(FtpSubscriptionPersistenceImpl.class); }