001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.tasks.service.persistence;
016    
017    import com.liferay.portal.NoSuchModelException;
018    import com.liferay.portal.kernel.annotation.BeanReference;
019    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
020    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
021    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderPath;
023    import com.liferay.portal.kernel.dao.orm.Query;
024    import com.liferay.portal.kernel.dao.orm.QueryPos;
025    import com.liferay.portal.kernel.dao.orm.QueryUtil;
026    import com.liferay.portal.kernel.dao.orm.SQLQuery;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.kernel.util.Validator;
038    import com.liferay.portal.model.ModelListener;
039    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
040    import com.liferay.portal.service.persistence.BatchSessionUtil;
041    import com.liferay.portal.service.persistence.ResourcePersistence;
042    import com.liferay.portal.service.persistence.UserPersistence;
043    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
044    
045    import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
046    import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
047    import com.liferay.portlet.tasks.NoSuchProposalException;
048    import com.liferay.portlet.tasks.model.TasksProposal;
049    import com.liferay.portlet.tasks.model.impl.TasksProposalImpl;
050    import com.liferay.portlet.tasks.model.impl.TasksProposalModelImpl;
051    
052    import java.io.Serializable;
053    
054    import java.util.ArrayList;
055    import java.util.Collections;
056    import java.util.List;
057    
058    /**
059     * @author    Brian Wing Shun Chan
060     * @see       TasksProposalPersistence
061     * @see       TasksProposalUtil
062     * @generated
063     */
064    public class TasksProposalPersistenceImpl extends BasePersistenceImpl<TasksProposal>
065            implements TasksProposalPersistence {
066            public static final String FINDER_CLASS_NAME_ENTITY = TasksProposalImpl.class.getName();
067            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
068                    ".List";
069            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
070                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
071                            FINDER_CLASS_NAME_LIST, "findByGroupId",
072                            new String[] {
073                                    Long.class.getName(),
074                                    
075                            "java.lang.Integer", "java.lang.Integer",
076                                    "com.liferay.portal.kernel.util.OrderByComparator"
077                            });
078            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
079                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
080                            FINDER_CLASS_NAME_LIST, "countByGroupId",
081                            new String[] { Long.class.getName() });
082            public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
083                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
084                            FINDER_CLASS_NAME_LIST, "findByG_U",
085                            new String[] {
086                                    Long.class.getName(), Long.class.getName(),
087                                    
088                            "java.lang.Integer", "java.lang.Integer",
089                                    "com.liferay.portal.kernel.util.OrderByComparator"
090                            });
091            public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
092                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
093                            FINDER_CLASS_NAME_LIST, "countByG_U",
094                            new String[] { Long.class.getName(), Long.class.getName() });
095            public static final FinderPath FINDER_PATH_FETCH_BY_C_C = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
096                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
097                            FINDER_CLASS_NAME_ENTITY, "fetchByC_C",
098                            new String[] { Long.class.getName(), String.class.getName() });
099            public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
100                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
101                            FINDER_CLASS_NAME_LIST, "countByC_C",
102                            new String[] { Long.class.getName(), String.class.getName() });
103            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
104                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
105                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
106            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
107                            TasksProposalModelImpl.FINDER_CACHE_ENABLED,
108                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
109    
110            public void cacheResult(TasksProposal tasksProposal) {
111                    EntityCacheUtil.putResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
112                            TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
113                            tasksProposal);
114    
115                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
116                            new Object[] {
117                                    new Long(tasksProposal.getClassNameId()),
118                                    
119                            tasksProposal.getClassPK()
120                            }, tasksProposal);
121            }
122    
123            public void cacheResult(List<TasksProposal> tasksProposals) {
124                    for (TasksProposal tasksProposal : tasksProposals) {
125                            if (EntityCacheUtil.getResult(
126                                                    TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
127                                                    TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
128                                                    this) == null) {
129                                    cacheResult(tasksProposal);
130                            }
131                    }
132            }
133    
134            public void clearCache() {
135                    CacheRegistryUtil.clear(TasksProposalImpl.class.getName());
136                    EntityCacheUtil.clearCache(TasksProposalImpl.class.getName());
137                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
138                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
139            }
140    
141            public void clearCache(TasksProposal tasksProposal) {
142                    EntityCacheUtil.removeResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
143                            TasksProposalImpl.class, tasksProposal.getPrimaryKey());
144    
145                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
146                            new Object[] {
147                                    new Long(tasksProposal.getClassNameId()),
148                                    
149                            tasksProposal.getClassPK()
150                            });
151            }
152    
153            public TasksProposal create(long proposalId) {
154                    TasksProposal tasksProposal = new TasksProposalImpl();
155    
156                    tasksProposal.setNew(true);
157                    tasksProposal.setPrimaryKey(proposalId);
158    
159                    return tasksProposal;
160            }
161    
162            public TasksProposal remove(Serializable primaryKey)
163                    throws NoSuchModelException, SystemException {
164                    return remove(((Long)primaryKey).longValue());
165            }
166    
167            public TasksProposal remove(long proposalId)
168                    throws NoSuchProposalException, SystemException {
169                    Session session = null;
170    
171                    try {
172                            session = openSession();
173    
174                            TasksProposal tasksProposal = (TasksProposal)session.get(TasksProposalImpl.class,
175                                            new Long(proposalId));
176    
177                            if (tasksProposal == null) {
178                                    if (_log.isWarnEnabled()) {
179                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + proposalId);
180                                    }
181    
182                                    throw new NoSuchProposalException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
183                                            proposalId);
184                            }
185    
186                            return remove(tasksProposal);
187                    }
188                    catch (NoSuchProposalException nsee) {
189                            throw nsee;
190                    }
191                    catch (Exception e) {
192                            throw processException(e);
193                    }
194                    finally {
195                            closeSession(session);
196                    }
197            }
198    
199            protected TasksProposal removeImpl(TasksProposal tasksProposal)
200                    throws SystemException {
201                    tasksProposal = toUnwrappedModel(tasksProposal);
202    
203                    Session session = null;
204    
205                    try {
206                            session = openSession();
207    
208                            if (tasksProposal.isCachedModel() || BatchSessionUtil.isEnabled()) {
209                                    Object staleObject = session.get(TasksProposalImpl.class,
210                                                    tasksProposal.getPrimaryKeyObj());
211    
212                                    if (staleObject != null) {
213                                            session.evict(staleObject);
214                                    }
215                            }
216    
217                            session.delete(tasksProposal);
218    
219                            session.flush();
220                    }
221                    catch (Exception e) {
222                            throw processException(e);
223                    }
224                    finally {
225                            closeSession(session);
226                    }
227    
228                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
229    
230                    TasksProposalModelImpl tasksProposalModelImpl = (TasksProposalModelImpl)tasksProposal;
231    
232                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
233                            new Object[] {
234                                    new Long(tasksProposalModelImpl.getOriginalClassNameId()),
235                                    
236                            tasksProposalModelImpl.getOriginalClassPK()
237                            });
238    
239                    EntityCacheUtil.removeResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
240                            TasksProposalImpl.class, tasksProposal.getPrimaryKey());
241    
242                    return tasksProposal;
243            }
244    
245            public TasksProposal updateImpl(
246                    com.liferay.portlet.tasks.model.TasksProposal tasksProposal,
247                    boolean merge) throws SystemException {
248                    tasksProposal = toUnwrappedModel(tasksProposal);
249    
250                    boolean isNew = tasksProposal.isNew();
251    
252                    TasksProposalModelImpl tasksProposalModelImpl = (TasksProposalModelImpl)tasksProposal;
253    
254                    Session session = null;
255    
256                    try {
257                            session = openSession();
258    
259                            BatchSessionUtil.update(session, tasksProposal, merge);
260    
261                            tasksProposal.setNew(false);
262                    }
263                    catch (Exception e) {
264                            throw processException(e);
265                    }
266                    finally {
267                            closeSession(session);
268                    }
269    
270                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
271    
272                    EntityCacheUtil.putResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
273                            TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
274                            tasksProposal);
275    
276                    if (!isNew &&
277                                    ((tasksProposal.getClassNameId() != tasksProposalModelImpl.getOriginalClassNameId()) ||
278                                    !Validator.equals(tasksProposal.getClassPK(),
279                                            tasksProposalModelImpl.getOriginalClassPK()))) {
280                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
281                                    new Object[] {
282                                            new Long(tasksProposalModelImpl.getOriginalClassNameId()),
283                                            
284                                    tasksProposalModelImpl.getOriginalClassPK()
285                                    });
286                    }
287    
288                    if (isNew ||
289                                    ((tasksProposal.getClassNameId() != tasksProposalModelImpl.getOriginalClassNameId()) ||
290                                    !Validator.equals(tasksProposal.getClassPK(),
291                                            tasksProposalModelImpl.getOriginalClassPK()))) {
292                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
293                                    new Object[] {
294                                            new Long(tasksProposal.getClassNameId()),
295                                            
296                                    tasksProposal.getClassPK()
297                                    }, tasksProposal);
298                    }
299    
300                    return tasksProposal;
301            }
302    
303            protected TasksProposal toUnwrappedModel(TasksProposal tasksProposal) {
304                    if (tasksProposal instanceof TasksProposalImpl) {
305                            return tasksProposal;
306                    }
307    
308                    TasksProposalImpl tasksProposalImpl = new TasksProposalImpl();
309    
310                    tasksProposalImpl.setNew(tasksProposal.isNew());
311                    tasksProposalImpl.setPrimaryKey(tasksProposal.getPrimaryKey());
312    
313                    tasksProposalImpl.setProposalId(tasksProposal.getProposalId());
314                    tasksProposalImpl.setGroupId(tasksProposal.getGroupId());
315                    tasksProposalImpl.setCompanyId(tasksProposal.getCompanyId());
316                    tasksProposalImpl.setUserId(tasksProposal.getUserId());
317                    tasksProposalImpl.setUserName(tasksProposal.getUserName());
318                    tasksProposalImpl.setCreateDate(tasksProposal.getCreateDate());
319                    tasksProposalImpl.setModifiedDate(tasksProposal.getModifiedDate());
320                    tasksProposalImpl.setClassNameId(tasksProposal.getClassNameId());
321                    tasksProposalImpl.setClassPK(tasksProposal.getClassPK());
322                    tasksProposalImpl.setName(tasksProposal.getName());
323                    tasksProposalImpl.setDescription(tasksProposal.getDescription());
324                    tasksProposalImpl.setPublishDate(tasksProposal.getPublishDate());
325                    tasksProposalImpl.setDueDate(tasksProposal.getDueDate());
326    
327                    return tasksProposalImpl;
328            }
329    
330            public TasksProposal findByPrimaryKey(Serializable primaryKey)
331                    throws NoSuchModelException, SystemException {
332                    return findByPrimaryKey(((Long)primaryKey).longValue());
333            }
334    
335            public TasksProposal findByPrimaryKey(long proposalId)
336                    throws NoSuchProposalException, SystemException {
337                    TasksProposal tasksProposal = fetchByPrimaryKey(proposalId);
338    
339                    if (tasksProposal == null) {
340                            if (_log.isWarnEnabled()) {
341                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + proposalId);
342                            }
343    
344                            throw new NoSuchProposalException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
345                                    proposalId);
346                    }
347    
348                    return tasksProposal;
349            }
350    
351            public TasksProposal fetchByPrimaryKey(Serializable primaryKey)
352                    throws SystemException {
353                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
354            }
355    
356            public TasksProposal fetchByPrimaryKey(long proposalId)
357                    throws SystemException {
358                    TasksProposal tasksProposal = (TasksProposal)EntityCacheUtil.getResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
359                                    TasksProposalImpl.class, proposalId, this);
360    
361                    if (tasksProposal == null) {
362                            Session session = null;
363    
364                            try {
365                                    session = openSession();
366    
367                                    tasksProposal = (TasksProposal)session.get(TasksProposalImpl.class,
368                                                    new Long(proposalId));
369                            }
370                            catch (Exception e) {
371                                    throw processException(e);
372                            }
373                            finally {
374                                    if (tasksProposal != null) {
375                                            cacheResult(tasksProposal);
376                                    }
377    
378                                    closeSession(session);
379                            }
380                    }
381    
382                    return tasksProposal;
383            }
384    
385            public List<TasksProposal> findByGroupId(long groupId)
386                    throws SystemException {
387                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
388            }
389    
390            public List<TasksProposal> findByGroupId(long groupId, int start, int end)
391                    throws SystemException {
392                    return findByGroupId(groupId, start, end, null);
393            }
394    
395            public List<TasksProposal> findByGroupId(long groupId, int start, int end,
396                    OrderByComparator orderByComparator) throws SystemException {
397                    Object[] finderArgs = new Object[] {
398                                    groupId,
399                                    
400                                    String.valueOf(start), String.valueOf(end),
401                                    String.valueOf(orderByComparator)
402                            };
403    
404                    List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
405                                    finderArgs, this);
406    
407                    if (list == null) {
408                            Session session = null;
409    
410                            try {
411                                    session = openSession();
412    
413                                    StringBundler query = null;
414    
415                                    if (orderByComparator != null) {
416                                            query = new StringBundler(3 +
417                                                            (orderByComparator.getOrderByFields().length * 3));
418                                    }
419                                    else {
420                                            query = new StringBundler(3);
421                                    }
422    
423                                    query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
424    
425                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
426    
427                                    if (orderByComparator != null) {
428                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
429                                                    orderByComparator);
430                                    }
431    
432                                    else {
433                                            query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
434                                    }
435    
436                                    String sql = query.toString();
437    
438                                    Query q = session.createQuery(sql);
439    
440                                    QueryPos qPos = QueryPos.getInstance(q);
441    
442                                    qPos.add(groupId);
443    
444                                    list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
445                                                    start, end);
446                            }
447                            catch (Exception e) {
448                                    throw processException(e);
449                            }
450                            finally {
451                                    if (list == null) {
452                                            list = new ArrayList<TasksProposal>();
453                                    }
454    
455                                    cacheResult(list);
456    
457                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
458                                            finderArgs, list);
459    
460                                    closeSession(session);
461                            }
462                    }
463    
464                    return list;
465            }
466    
467            public TasksProposal findByGroupId_First(long groupId,
468                    OrderByComparator orderByComparator)
469                    throws NoSuchProposalException, SystemException {
470                    List<TasksProposal> list = findByGroupId(groupId, 0, 1,
471                                    orderByComparator);
472    
473                    if (list.isEmpty()) {
474                            StringBundler msg = new StringBundler(4);
475    
476                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
477    
478                            msg.append("groupId=");
479                            msg.append(groupId);
480    
481                            msg.append(StringPool.CLOSE_CURLY_BRACE);
482    
483                            throw new NoSuchProposalException(msg.toString());
484                    }
485                    else {
486                            return list.get(0);
487                    }
488            }
489    
490            public TasksProposal findByGroupId_Last(long groupId,
491                    OrderByComparator orderByComparator)
492                    throws NoSuchProposalException, SystemException {
493                    int count = countByGroupId(groupId);
494    
495                    List<TasksProposal> list = findByGroupId(groupId, count - 1, count,
496                                    orderByComparator);
497    
498                    if (list.isEmpty()) {
499                            StringBundler msg = new StringBundler(4);
500    
501                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
502    
503                            msg.append("groupId=");
504                            msg.append(groupId);
505    
506                            msg.append(StringPool.CLOSE_CURLY_BRACE);
507    
508                            throw new NoSuchProposalException(msg.toString());
509                    }
510                    else {
511                            return list.get(0);
512                    }
513            }
514    
515            public TasksProposal[] findByGroupId_PrevAndNext(long proposalId,
516                    long groupId, OrderByComparator orderByComparator)
517                    throws NoSuchProposalException, SystemException {
518                    TasksProposal tasksProposal = findByPrimaryKey(proposalId);
519    
520                    Session session = null;
521    
522                    try {
523                            session = openSession();
524    
525                            TasksProposal[] array = new TasksProposalImpl[3];
526    
527                            array[0] = getByGroupId_PrevAndNext(session, tasksProposal,
528                                            groupId, orderByComparator, true);
529    
530                            array[1] = tasksProposal;
531    
532                            array[2] = getByGroupId_PrevAndNext(session, tasksProposal,
533                                            groupId, orderByComparator, false);
534    
535                            return array;
536                    }
537                    catch (Exception e) {
538                            throw processException(e);
539                    }
540                    finally {
541                            closeSession(session);
542                    }
543            }
544    
545            protected TasksProposal getByGroupId_PrevAndNext(Session session,
546                    TasksProposal tasksProposal, long groupId,
547                    OrderByComparator orderByComparator, boolean previous) {
548                    StringBundler query = null;
549    
550                    if (orderByComparator != null) {
551                            query = new StringBundler(6 +
552                                            (orderByComparator.getOrderByFields().length * 6));
553                    }
554                    else {
555                            query = new StringBundler(3);
556                    }
557    
558                    query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
559    
560                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
561    
562                    if (orderByComparator != null) {
563                            String[] orderByFields = orderByComparator.getOrderByFields();
564    
565                            if (orderByFields.length > 0) {
566                                    query.append(WHERE_AND);
567                            }
568    
569                            for (int i = 0; i < orderByFields.length; i++) {
570                                    query.append(_ORDER_BY_ENTITY_ALIAS);
571                                    query.append(orderByFields[i]);
572    
573                                    if ((i + 1) < orderByFields.length) {
574                                            if (orderByComparator.isAscending() ^ previous) {
575                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
576                                            }
577                                            else {
578                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
579                                            }
580                                    }
581                                    else {
582                                            if (orderByComparator.isAscending() ^ previous) {
583                                                    query.append(WHERE_GREATER_THAN);
584                                            }
585                                            else {
586                                                    query.append(WHERE_LESSER_THAN);
587                                            }
588                                    }
589                            }
590    
591                            query.append(ORDER_BY_CLAUSE);
592    
593                            for (int i = 0; i < orderByFields.length; i++) {
594                                    query.append(_ORDER_BY_ENTITY_ALIAS);
595                                    query.append(orderByFields[i]);
596    
597                                    if ((i + 1) < orderByFields.length) {
598                                            if (orderByComparator.isAscending() ^ previous) {
599                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
600                                            }
601                                            else {
602                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
603                                            }
604                                    }
605                                    else {
606                                            if (orderByComparator.isAscending() ^ previous) {
607                                                    query.append(ORDER_BY_ASC);
608                                            }
609                                            else {
610                                                    query.append(ORDER_BY_DESC);
611                                            }
612                                    }
613                            }
614                    }
615    
616                    else {
617                            query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
618                    }
619    
620                    String sql = query.toString();
621    
622                    Query q = session.createQuery(sql);
623    
624                    q.setFirstResult(0);
625                    q.setMaxResults(2);
626    
627                    QueryPos qPos = QueryPos.getInstance(q);
628    
629                    qPos.add(groupId);
630    
631                    if (orderByComparator != null) {
632                            Object[] values = orderByComparator.getOrderByValues(tasksProposal);
633    
634                            for (Object value : values) {
635                                    qPos.add(value);
636                            }
637                    }
638    
639                    List<TasksProposal> list = q.list();
640    
641                    if (list.size() == 2) {
642                            return list.get(1);
643                    }
644                    else {
645                            return null;
646                    }
647            }
648    
649            public List<TasksProposal> filterFindByGroupId(long groupId)
650                    throws SystemException {
651                    return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
652                            QueryUtil.ALL_POS, null);
653            }
654    
655            public List<TasksProposal> filterFindByGroupId(long groupId, int start,
656                    int end) throws SystemException {
657                    return filterFindByGroupId(groupId, start, end, null);
658            }
659    
660            public List<TasksProposal> filterFindByGroupId(long groupId, int start,
661                    int end, OrderByComparator orderByComparator) throws SystemException {
662                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
663                            return findByGroupId(groupId, start, end, orderByComparator);
664                    }
665    
666                    Session session = null;
667    
668                    try {
669                            session = openSession();
670    
671                            StringBundler query = null;
672    
673                            if (orderByComparator != null) {
674                                    query = new StringBundler(3 +
675                                                    (orderByComparator.getOrderByFields().length * 3));
676                            }
677                            else {
678                                    query = new StringBundler(3);
679                            }
680    
681                            query.append(_FILTER_SQL_SELECT_TASKSPROPOSAL_WHERE);
682    
683                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
684    
685                            if (orderByComparator != null) {
686                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
687                                            orderByComparator);
688                            }
689    
690                            else {
691                                    query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
692                            }
693    
694                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
695                                            TasksProposal.class.getName(), _FILTER_COLUMN_PK,
696                                            _FILTER_COLUMN_USERID, groupId);
697    
698                            SQLQuery q = session.createSQLQuery(sql);
699    
700                            q.addEntity(_FILTER_ENTITY_ALIAS, TasksProposalImpl.class);
701    
702                            QueryPos qPos = QueryPos.getInstance(q);
703    
704                            qPos.add(groupId);
705    
706                            return (List<TasksProposal>)QueryUtil.list(q, getDialect(), start,
707                                    end);
708                    }
709                    catch (Exception e) {
710                            throw processException(e);
711                    }
712                    finally {
713                            closeSession(session);
714                    }
715            }
716    
717            public List<TasksProposal> findByG_U(long groupId, long userId)
718                    throws SystemException {
719                    return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
720                            null);
721            }
722    
723            public List<TasksProposal> findByG_U(long groupId, long userId, int start,
724                    int end) throws SystemException {
725                    return findByG_U(groupId, userId, start, end, null);
726            }
727    
728            public List<TasksProposal> findByG_U(long groupId, long userId, int start,
729                    int end, OrderByComparator orderByComparator) throws SystemException {
730                    Object[] finderArgs = new Object[] {
731                                    groupId, userId,
732                                    
733                                    String.valueOf(start), String.valueOf(end),
734                                    String.valueOf(orderByComparator)
735                            };
736    
737                    List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
738                                    finderArgs, this);
739    
740                    if (list == null) {
741                            Session session = null;
742    
743                            try {
744                                    session = openSession();
745    
746                                    StringBundler query = null;
747    
748                                    if (orderByComparator != null) {
749                                            query = new StringBundler(4 +
750                                                            (orderByComparator.getOrderByFields().length * 3));
751                                    }
752                                    else {
753                                            query = new StringBundler(4);
754                                    }
755    
756                                    query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
757    
758                                    query.append(_FINDER_COLUMN_G_U_GROUPID_2);
759    
760                                    query.append(_FINDER_COLUMN_G_U_USERID_2);
761    
762                                    if (orderByComparator != null) {
763                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
764                                                    orderByComparator);
765                                    }
766    
767                                    else {
768                                            query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
769                                    }
770    
771                                    String sql = query.toString();
772    
773                                    Query q = session.createQuery(sql);
774    
775                                    QueryPos qPos = QueryPos.getInstance(q);
776    
777                                    qPos.add(groupId);
778    
779                                    qPos.add(userId);
780    
781                                    list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
782                                                    start, end);
783                            }
784                            catch (Exception e) {
785                                    throw processException(e);
786                            }
787                            finally {
788                                    if (list == null) {
789                                            list = new ArrayList<TasksProposal>();
790                                    }
791    
792                                    cacheResult(list);
793    
794                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
795                                            list);
796    
797                                    closeSession(session);
798                            }
799                    }
800    
801                    return list;
802            }
803    
804            public TasksProposal findByG_U_First(long groupId, long userId,
805                    OrderByComparator orderByComparator)
806                    throws NoSuchProposalException, SystemException {
807                    List<TasksProposal> list = findByG_U(groupId, userId, 0, 1,
808                                    orderByComparator);
809    
810                    if (list.isEmpty()) {
811                            StringBundler msg = new StringBundler(6);
812    
813                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
814    
815                            msg.append("groupId=");
816                            msg.append(groupId);
817    
818                            msg.append(", userId=");
819                            msg.append(userId);
820    
821                            msg.append(StringPool.CLOSE_CURLY_BRACE);
822    
823                            throw new NoSuchProposalException(msg.toString());
824                    }
825                    else {
826                            return list.get(0);
827                    }
828            }
829    
830            public TasksProposal findByG_U_Last(long groupId, long userId,
831                    OrderByComparator orderByComparator)
832                    throws NoSuchProposalException, SystemException {
833                    int count = countByG_U(groupId, userId);
834    
835                    List<TasksProposal> list = findByG_U(groupId, userId, count - 1, count,
836                                    orderByComparator);
837    
838                    if (list.isEmpty()) {
839                            StringBundler msg = new StringBundler(6);
840    
841                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
842    
843                            msg.append("groupId=");
844                            msg.append(groupId);
845    
846                            msg.append(", userId=");
847                            msg.append(userId);
848    
849                            msg.append(StringPool.CLOSE_CURLY_BRACE);
850    
851                            throw new NoSuchProposalException(msg.toString());
852                    }
853                    else {
854                            return list.get(0);
855                    }
856            }
857    
858            public TasksProposal[] findByG_U_PrevAndNext(long proposalId, long groupId,
859                    long userId, OrderByComparator orderByComparator)
860                    throws NoSuchProposalException, SystemException {
861                    TasksProposal tasksProposal = findByPrimaryKey(proposalId);
862    
863                    Session session = null;
864    
865                    try {
866                            session = openSession();
867    
868                            TasksProposal[] array = new TasksProposalImpl[3];
869    
870                            array[0] = getByG_U_PrevAndNext(session, tasksProposal, groupId,
871                                            userId, orderByComparator, true);
872    
873                            array[1] = tasksProposal;
874    
875                            array[2] = getByG_U_PrevAndNext(session, tasksProposal, groupId,
876                                            userId, orderByComparator, false);
877    
878                            return array;
879                    }
880                    catch (Exception e) {
881                            throw processException(e);
882                    }
883                    finally {
884                            closeSession(session);
885                    }
886            }
887    
888            protected TasksProposal getByG_U_PrevAndNext(Session session,
889                    TasksProposal tasksProposal, long groupId, long userId,
890                    OrderByComparator orderByComparator, boolean previous) {
891                    StringBundler query = null;
892    
893                    if (orderByComparator != null) {
894                            query = new StringBundler(6 +
895                                            (orderByComparator.getOrderByFields().length * 6));
896                    }
897                    else {
898                            query = new StringBundler(3);
899                    }
900    
901                    query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
902    
903                    query.append(_FINDER_COLUMN_G_U_GROUPID_2);
904    
905                    query.append(_FINDER_COLUMN_G_U_USERID_2);
906    
907                    if (orderByComparator != null) {
908                            String[] orderByFields = orderByComparator.getOrderByFields();
909    
910                            if (orderByFields.length > 0) {
911                                    query.append(WHERE_AND);
912                            }
913    
914                            for (int i = 0; i < orderByFields.length; i++) {
915                                    query.append(_ORDER_BY_ENTITY_ALIAS);
916                                    query.append(orderByFields[i]);
917    
918                                    if ((i + 1) < orderByFields.length) {
919                                            if (orderByComparator.isAscending() ^ previous) {
920                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
921                                            }
922                                            else {
923                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
924                                            }
925                                    }
926                                    else {
927                                            if (orderByComparator.isAscending() ^ previous) {
928                                                    query.append(WHERE_GREATER_THAN);
929                                            }
930                                            else {
931                                                    query.append(WHERE_LESSER_THAN);
932                                            }
933                                    }
934                            }
935    
936                            query.append(ORDER_BY_CLAUSE);
937    
938                            for (int i = 0; i < orderByFields.length; i++) {
939                                    query.append(_ORDER_BY_ENTITY_ALIAS);
940                                    query.append(orderByFields[i]);
941    
942                                    if ((i + 1) < orderByFields.length) {
943                                            if (orderByComparator.isAscending() ^ previous) {
944                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
945                                            }
946                                            else {
947                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
948                                            }
949                                    }
950                                    else {
951                                            if (orderByComparator.isAscending() ^ previous) {
952                                                    query.append(ORDER_BY_ASC);
953                                            }
954                                            else {
955                                                    query.append(ORDER_BY_DESC);
956                                            }
957                                    }
958                            }
959                    }
960    
961                    else {
962                            query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
963                    }
964    
965                    String sql = query.toString();
966    
967                    Query q = session.createQuery(sql);
968    
969                    q.setFirstResult(0);
970                    q.setMaxResults(2);
971    
972                    QueryPos qPos = QueryPos.getInstance(q);
973    
974                    qPos.add(groupId);
975    
976                    qPos.add(userId);
977    
978                    if (orderByComparator != null) {
979                            Object[] values = orderByComparator.getOrderByValues(tasksProposal);
980    
981                            for (Object value : values) {
982                                    qPos.add(value);
983                            }
984                    }
985    
986                    List<TasksProposal> list = q.list();
987    
988                    if (list.size() == 2) {
989                            return list.get(1);
990                    }
991                    else {
992                            return null;
993                    }
994            }
995    
996            public List<TasksProposal> filterFindByG_U(long groupId, long userId)
997                    throws SystemException {
998                    return filterFindByG_U(groupId, userId, QueryUtil.ALL_POS,
999                            QueryUtil.ALL_POS, null);
1000            }
1001    
1002            public List<TasksProposal> filterFindByG_U(long groupId, long userId,
1003                    int start, int end) throws SystemException {
1004                    return filterFindByG_U(groupId, userId, start, end, null);
1005            }
1006    
1007            public List<TasksProposal> filterFindByG_U(long groupId, long userId,
1008                    int start, int end, OrderByComparator orderByComparator)
1009                    throws SystemException {
1010                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1011                            return findByG_U(groupId, userId, start, end, orderByComparator);
1012                    }
1013    
1014                    Session session = null;
1015    
1016                    try {
1017                            session = openSession();
1018    
1019                            StringBundler query = null;
1020    
1021                            if (orderByComparator != null) {
1022                                    query = new StringBundler(4 +
1023                                                    (orderByComparator.getOrderByFields().length * 3));
1024                            }
1025                            else {
1026                                    query = new StringBundler(4);
1027                            }
1028    
1029                            query.append(_FILTER_SQL_SELECT_TASKSPROPOSAL_WHERE);
1030    
1031                            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1032    
1033                            query.append(_FINDER_COLUMN_G_U_USERID_2);
1034    
1035                            if (orderByComparator != null) {
1036                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1037                                            orderByComparator);
1038                            }
1039    
1040                            else {
1041                                    query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
1042                            }
1043    
1044                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1045                                            TasksProposal.class.getName(), _FILTER_COLUMN_PK,
1046                                            _FILTER_COLUMN_USERID, groupId);
1047    
1048                            SQLQuery q = session.createSQLQuery(sql);
1049    
1050                            q.addEntity(_FILTER_ENTITY_ALIAS, TasksProposalImpl.class);
1051    
1052                            QueryPos qPos = QueryPos.getInstance(q);
1053    
1054                            qPos.add(groupId);
1055    
1056                            qPos.add(userId);
1057    
1058                            return (List<TasksProposal>)QueryUtil.list(q, getDialect(), start,
1059                                    end);
1060                    }
1061                    catch (Exception e) {
1062                            throw processException(e);
1063                    }
1064                    finally {
1065                            closeSession(session);
1066                    }
1067            }
1068    
1069            public TasksProposal findByC_C(long classNameId, String classPK)
1070                    throws NoSuchProposalException, SystemException {
1071                    TasksProposal tasksProposal = fetchByC_C(classNameId, classPK);
1072    
1073                    if (tasksProposal == null) {
1074                            StringBundler msg = new StringBundler(6);
1075    
1076                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1077    
1078                            msg.append("classNameId=");
1079                            msg.append(classNameId);
1080    
1081                            msg.append(", classPK=");
1082                            msg.append(classPK);
1083    
1084                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1085    
1086                            if (_log.isWarnEnabled()) {
1087                                    _log.warn(msg.toString());
1088                            }
1089    
1090                            throw new NoSuchProposalException(msg.toString());
1091                    }
1092    
1093                    return tasksProposal;
1094            }
1095    
1096            public TasksProposal fetchByC_C(long classNameId, String classPK)
1097                    throws SystemException {
1098                    return fetchByC_C(classNameId, classPK, true);
1099            }
1100    
1101            public TasksProposal fetchByC_C(long classNameId, String classPK,
1102                    boolean retrieveFromCache) throws SystemException {
1103                    Object[] finderArgs = new Object[] { classNameId, classPK };
1104    
1105                    Object result = null;
1106    
1107                    if (retrieveFromCache) {
1108                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_C,
1109                                            finderArgs, this);
1110                    }
1111    
1112                    if (result == null) {
1113                            Session session = null;
1114    
1115                            try {
1116                                    session = openSession();
1117    
1118                                    StringBundler query = new StringBundler(4);
1119    
1120                                    query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
1121    
1122                                    query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1123    
1124                                    if (classPK == null) {
1125                                            query.append(_FINDER_COLUMN_C_C_CLASSPK_1);
1126                                    }
1127                                    else {
1128                                            if (classPK.equals(StringPool.BLANK)) {
1129                                                    query.append(_FINDER_COLUMN_C_C_CLASSPK_3);
1130                                            }
1131                                            else {
1132                                                    query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
1133                                            }
1134                                    }
1135    
1136                                    query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
1137    
1138                                    String sql = query.toString();
1139    
1140                                    Query q = session.createQuery(sql);
1141    
1142                                    QueryPos qPos = QueryPos.getInstance(q);
1143    
1144                                    qPos.add(classNameId);
1145    
1146                                    if (classPK != null) {
1147                                            qPos.add(classPK);
1148                                    }
1149    
1150                                    List<TasksProposal> list = q.list();
1151    
1152                                    result = list;
1153    
1154                                    TasksProposal tasksProposal = null;
1155    
1156                                    if (list.isEmpty()) {
1157                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1158                                                    finderArgs, list);
1159                                    }
1160                                    else {
1161                                            tasksProposal = list.get(0);
1162    
1163                                            cacheResult(tasksProposal);
1164    
1165                                            if ((tasksProposal.getClassNameId() != classNameId) ||
1166                                                            (tasksProposal.getClassPK() == null) ||
1167                                                            !tasksProposal.getClassPK().equals(classPK)) {
1168                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1169                                                            finderArgs, tasksProposal);
1170                                            }
1171                                    }
1172    
1173                                    return tasksProposal;
1174                            }
1175                            catch (Exception e) {
1176                                    throw processException(e);
1177                            }
1178                            finally {
1179                                    if (result == null) {
1180                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1181                                                    finderArgs, new ArrayList<TasksProposal>());
1182                                    }
1183    
1184                                    closeSession(session);
1185                            }
1186                    }
1187                    else {
1188                            if (result instanceof List<?>) {
1189                                    return null;
1190                            }
1191                            else {
1192                                    return (TasksProposal)result;
1193                            }
1194                    }
1195            }
1196    
1197            public List<TasksProposal> findAll() throws SystemException {
1198                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1199            }
1200    
1201            public List<TasksProposal> findAll(int start, int end)
1202                    throws SystemException {
1203                    return findAll(start, end, null);
1204            }
1205    
1206            public List<TasksProposal> findAll(int start, int end,
1207                    OrderByComparator orderByComparator) throws SystemException {
1208                    Object[] finderArgs = new Object[] {
1209                                    String.valueOf(start), String.valueOf(end),
1210                                    String.valueOf(orderByComparator)
1211                            };
1212    
1213                    List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1214                                    finderArgs, this);
1215    
1216                    if (list == null) {
1217                            Session session = null;
1218    
1219                            try {
1220                                    session = openSession();
1221    
1222                                    StringBundler query = null;
1223                                    String sql = null;
1224    
1225                                    if (orderByComparator != null) {
1226                                            query = new StringBundler(2 +
1227                                                            (orderByComparator.getOrderByFields().length * 3));
1228    
1229                                            query.append(_SQL_SELECT_TASKSPROPOSAL);
1230    
1231                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1232                                                    orderByComparator);
1233    
1234                                            sql = query.toString();
1235                                    }
1236                                    else {
1237                                            sql = _SQL_SELECT_TASKSPROPOSAL.concat(TasksProposalModelImpl.ORDER_BY_JPQL);
1238                                    }
1239    
1240                                    Query q = session.createQuery(sql);
1241    
1242                                    if (orderByComparator == null) {
1243                                            list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
1244                                                            start, end, false);
1245    
1246                                            Collections.sort(list);
1247                                    }
1248                                    else {
1249                                            list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
1250                                                            start, end);
1251                                    }
1252                            }
1253                            catch (Exception e) {
1254                                    throw processException(e);
1255                            }
1256                            finally {
1257                                    if (list == null) {
1258                                            list = new ArrayList<TasksProposal>();
1259                                    }
1260    
1261                                    cacheResult(list);
1262    
1263                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1264    
1265                                    closeSession(session);
1266                            }
1267                    }
1268    
1269                    return list;
1270            }
1271    
1272            public void removeByGroupId(long groupId) throws SystemException {
1273                    for (TasksProposal tasksProposal : findByGroupId(groupId)) {
1274                            remove(tasksProposal);
1275                    }
1276            }
1277    
1278            public void removeByG_U(long groupId, long userId)
1279                    throws SystemException {
1280                    for (TasksProposal tasksProposal : findByG_U(groupId, userId)) {
1281                            remove(tasksProposal);
1282                    }
1283            }
1284    
1285            public void removeByC_C(long classNameId, String classPK)
1286                    throws NoSuchProposalException, SystemException {
1287                    TasksProposal tasksProposal = findByC_C(classNameId, classPK);
1288    
1289                    remove(tasksProposal);
1290            }
1291    
1292            public void removeAll() throws SystemException {
1293                    for (TasksProposal tasksProposal : findAll()) {
1294                            remove(tasksProposal);
1295                    }
1296            }
1297    
1298            public int countByGroupId(long groupId) throws SystemException {
1299                    Object[] finderArgs = new Object[] { groupId };
1300    
1301                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1302                                    finderArgs, this);
1303    
1304                    if (count == null) {
1305                            Session session = null;
1306    
1307                            try {
1308                                    session = openSession();
1309    
1310                                    StringBundler query = new StringBundler(2);
1311    
1312                                    query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1313    
1314                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1315    
1316                                    String sql = query.toString();
1317    
1318                                    Query q = session.createQuery(sql);
1319    
1320                                    QueryPos qPos = QueryPos.getInstance(q);
1321    
1322                                    qPos.add(groupId);
1323    
1324                                    count = (Long)q.uniqueResult();
1325                            }
1326                            catch (Exception e) {
1327                                    throw processException(e);
1328                            }
1329                            finally {
1330                                    if (count == null) {
1331                                            count = Long.valueOf(0);
1332                                    }
1333    
1334                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1335                                            finderArgs, count);
1336    
1337                                    closeSession(session);
1338                            }
1339                    }
1340    
1341                    return count.intValue();
1342            }
1343    
1344            public int filterCountByGroupId(long groupId) throws SystemException {
1345                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1346                            return countByGroupId(groupId);
1347                    }
1348    
1349                    Session session = null;
1350    
1351                    try {
1352                            session = openSession();
1353    
1354                            StringBundler query = new StringBundler(2);
1355    
1356                            query.append(_FILTER_SQL_COUNT_TASKSPROPOSAL_WHERE);
1357    
1358                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1359    
1360                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1361                                            TasksProposal.class.getName(), _FILTER_COLUMN_PK,
1362                                            _FILTER_COLUMN_USERID, groupId);
1363    
1364                            SQLQuery q = session.createSQLQuery(sql);
1365    
1366                            q.addScalar(COUNT_COLUMN_NAME,
1367                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
1368    
1369                            QueryPos qPos = QueryPos.getInstance(q);
1370    
1371                            qPos.add(groupId);
1372    
1373                            Long count = (Long)q.uniqueResult();
1374    
1375                            return count.intValue();
1376                    }
1377                    catch (Exception e) {
1378                            throw processException(e);
1379                    }
1380                    finally {
1381                            closeSession(session);
1382                    }
1383            }
1384    
1385            public int countByG_U(long groupId, long userId) throws SystemException {
1386                    Object[] finderArgs = new Object[] { groupId, userId };
1387    
1388                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1389                                    finderArgs, this);
1390    
1391                    if (count == null) {
1392                            Session session = null;
1393    
1394                            try {
1395                                    session = openSession();
1396    
1397                                    StringBundler query = new StringBundler(3);
1398    
1399                                    query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1400    
1401                                    query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1402    
1403                                    query.append(_FINDER_COLUMN_G_U_USERID_2);
1404    
1405                                    String sql = query.toString();
1406    
1407                                    Query q = session.createQuery(sql);
1408    
1409                                    QueryPos qPos = QueryPos.getInstance(q);
1410    
1411                                    qPos.add(groupId);
1412    
1413                                    qPos.add(userId);
1414    
1415                                    count = (Long)q.uniqueResult();
1416                            }
1417                            catch (Exception e) {
1418                                    throw processException(e);
1419                            }
1420                            finally {
1421                                    if (count == null) {
1422                                            count = Long.valueOf(0);
1423                                    }
1424    
1425                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1426                                            count);
1427    
1428                                    closeSession(session);
1429                            }
1430                    }
1431    
1432                    return count.intValue();
1433            }
1434    
1435            public int filterCountByG_U(long groupId, long userId)
1436                    throws SystemException {
1437                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1438                            return countByG_U(groupId, userId);
1439                    }
1440    
1441                    Session session = null;
1442    
1443                    try {
1444                            session = openSession();
1445    
1446                            StringBundler query = new StringBundler(3);
1447    
1448                            query.append(_FILTER_SQL_COUNT_TASKSPROPOSAL_WHERE);
1449    
1450                            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1451    
1452                            query.append(_FINDER_COLUMN_G_U_USERID_2);
1453    
1454                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1455                                            TasksProposal.class.getName(), _FILTER_COLUMN_PK,
1456                                            _FILTER_COLUMN_USERID, groupId);
1457    
1458                            SQLQuery q = session.createSQLQuery(sql);
1459    
1460                            q.addScalar(COUNT_COLUMN_NAME,
1461                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
1462    
1463                            QueryPos qPos = QueryPos.getInstance(q);
1464    
1465                            qPos.add(groupId);
1466    
1467                            qPos.add(userId);
1468    
1469                            Long count = (Long)q.uniqueResult();
1470    
1471                            return count.intValue();
1472                    }
1473                    catch (Exception e) {
1474                            throw processException(e);
1475                    }
1476                    finally {
1477                            closeSession(session);
1478                    }
1479            }
1480    
1481            public int countByC_C(long classNameId, String classPK)
1482                    throws SystemException {
1483                    Object[] finderArgs = new Object[] { classNameId, classPK };
1484    
1485                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
1486                                    finderArgs, this);
1487    
1488                    if (count == null) {
1489                            Session session = null;
1490    
1491                            try {
1492                                    session = openSession();
1493    
1494                                    StringBundler query = new StringBundler(3);
1495    
1496                                    query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1497    
1498                                    query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1499    
1500                                    if (classPK == null) {
1501                                            query.append(_FINDER_COLUMN_C_C_CLASSPK_1);
1502                                    }
1503                                    else {
1504                                            if (classPK.equals(StringPool.BLANK)) {
1505                                                    query.append(_FINDER_COLUMN_C_C_CLASSPK_3);
1506                                            }
1507                                            else {
1508                                                    query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
1509                                            }
1510                                    }
1511    
1512                                    String sql = query.toString();
1513    
1514                                    Query q = session.createQuery(sql);
1515    
1516                                    QueryPos qPos = QueryPos.getInstance(q);
1517    
1518                                    qPos.add(classNameId);
1519    
1520                                    if (classPK != null) {
1521                                            qPos.add(classPK);
1522                                    }
1523    
1524                                    count = (Long)q.uniqueResult();
1525                            }
1526                            catch (Exception e) {
1527                                    throw processException(e);
1528                            }
1529                            finally {
1530                                    if (count == null) {
1531                                            count = Long.valueOf(0);
1532                                    }
1533    
1534                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
1535                                            count);
1536    
1537                                    closeSession(session);
1538                            }
1539                    }
1540    
1541                    return count.intValue();
1542            }
1543    
1544            public int countAll() throws SystemException {
1545                    Object[] finderArgs = new Object[0];
1546    
1547                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1548                                    finderArgs, this);
1549    
1550                    if (count == null) {
1551                            Session session = null;
1552    
1553                            try {
1554                                    session = openSession();
1555    
1556                                    Query q = session.createQuery(_SQL_COUNT_TASKSPROPOSAL);
1557    
1558                                    count = (Long)q.uniqueResult();
1559                            }
1560                            catch (Exception e) {
1561                                    throw processException(e);
1562                            }
1563                            finally {
1564                                    if (count == null) {
1565                                            count = Long.valueOf(0);
1566                                    }
1567    
1568                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1569                                            count);
1570    
1571                                    closeSession(session);
1572                            }
1573                    }
1574    
1575                    return count.intValue();
1576            }
1577    
1578            public void afterPropertiesSet() {
1579                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1580                                            com.liferay.portal.util.PropsUtil.get(
1581                                                    "value.object.listener.com.liferay.portlet.tasks.model.TasksProposal")));
1582    
1583                    if (listenerClassNames.length > 0) {
1584                            try {
1585                                    List<ModelListener<TasksProposal>> listenersList = new ArrayList<ModelListener<TasksProposal>>();
1586    
1587                                    for (String listenerClassName : listenerClassNames) {
1588                                            listenersList.add((ModelListener<TasksProposal>)InstanceFactory.newInstance(
1589                                                            listenerClassName));
1590                                    }
1591    
1592                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1593                            }
1594                            catch (Exception e) {
1595                                    _log.error(e);
1596                            }
1597                    }
1598            }
1599    
1600            @BeanReference(type = TasksProposalPersistence.class)
1601            protected TasksProposalPersistence tasksProposalPersistence;
1602            @BeanReference(type = TasksReviewPersistence.class)
1603            protected TasksReviewPersistence tasksReviewPersistence;
1604            @BeanReference(type = ResourcePersistence.class)
1605            protected ResourcePersistence resourcePersistence;
1606            @BeanReference(type = UserPersistence.class)
1607            protected UserPersistence userPersistence;
1608            @BeanReference(type = MBMessagePersistence.class)
1609            protected MBMessagePersistence mbMessagePersistence;
1610            @BeanReference(type = SocialActivityPersistence.class)
1611            protected SocialActivityPersistence socialActivityPersistence;
1612            private static final String _SQL_SELECT_TASKSPROPOSAL = "SELECT tasksProposal FROM TasksProposal tasksProposal";
1613            private static final String _SQL_SELECT_TASKSPROPOSAL_WHERE = "SELECT tasksProposal FROM TasksProposal tasksProposal WHERE ";
1614            private static final String _SQL_COUNT_TASKSPROPOSAL = "SELECT COUNT(tasksProposal) FROM TasksProposal tasksProposal";
1615            private static final String _SQL_COUNT_TASKSPROPOSAL_WHERE = "SELECT COUNT(tasksProposal) FROM TasksProposal tasksProposal WHERE ";
1616            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "tasksProposal.groupId = ?";
1617            private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "tasksProposal.groupId = ? AND ";
1618            private static final String _FINDER_COLUMN_G_U_USERID_2 = "tasksProposal.userId = ?";
1619            private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "tasksProposal.classNameId = ? AND ";
1620            private static final String _FINDER_COLUMN_C_C_CLASSPK_1 = "tasksProposal.classPK IS NULL";
1621            private static final String _FINDER_COLUMN_C_C_CLASSPK_2 = "tasksProposal.classPK = ?";
1622            private static final String _FINDER_COLUMN_C_C_CLASSPK_3 = "(tasksProposal.classPK IS NULL OR tasksProposal.classPK = ?)";
1623            private static final String _FILTER_SQL_SELECT_TASKSPROPOSAL_WHERE = "SELECT DISTINCT {tasksProposal.*} FROM TasksProposal tasksProposal WHERE ";
1624            private static final String _FILTER_SQL_COUNT_TASKSPROPOSAL_WHERE = "SELECT COUNT(DISTINCT tasksProposal.proposalId) AS COUNT_VALUE FROM TasksProposal tasksProposal WHERE ";
1625            private static final String _FILTER_COLUMN_PK = "tasksProposal.proposalId";
1626            private static final String _FILTER_COLUMN_USERID = "tasksProposal.userId";
1627            private static final String _FILTER_ENTITY_ALIAS = "tasksProposal";
1628            private static final String _ORDER_BY_ENTITY_ALIAS = "tasksProposal.";
1629            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No TasksProposal exists with the primary key ";
1630            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No TasksProposal exists with the key {";
1631            private static Log _log = LogFactoryUtil.getLog(TasksProposalPersistenceImpl.class);
1632    }