001    /**
002     * Copyright (c) 2000-2013 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.portal.service.persistence;
016    
017    import com.liferay.portal.NoSuchUserNotificationEventException;
018    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
019    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
020    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
021    import com.liferay.portal.kernel.dao.orm.FinderPath;
022    import com.liferay.portal.kernel.dao.orm.Query;
023    import com.liferay.portal.kernel.dao.orm.QueryPos;
024    import com.liferay.portal.kernel.dao.orm.QueryUtil;
025    import com.liferay.portal.kernel.dao.orm.Session;
026    import com.liferay.portal.kernel.exception.SystemException;
027    import com.liferay.portal.kernel.log.Log;
028    import com.liferay.portal.kernel.log.LogFactoryUtil;
029    import com.liferay.portal.kernel.util.GetterUtil;
030    import com.liferay.portal.kernel.util.InstanceFactory;
031    import com.liferay.portal.kernel.util.OrderByComparator;
032    import com.liferay.portal.kernel.util.SetUtil;
033    import com.liferay.portal.kernel.util.StringBundler;
034    import com.liferay.portal.kernel.util.StringPool;
035    import com.liferay.portal.kernel.util.StringUtil;
036    import com.liferay.portal.kernel.util.UnmodifiableList;
037    import com.liferay.portal.kernel.util.Validator;
038    import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
039    import com.liferay.portal.model.CacheModel;
040    import com.liferay.portal.model.ModelListener;
041    import com.liferay.portal.model.UserNotificationEvent;
042    import com.liferay.portal.model.impl.UserNotificationEventImpl;
043    import com.liferay.portal.model.impl.UserNotificationEventModelImpl;
044    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
045    
046    import java.io.Serializable;
047    
048    import java.util.ArrayList;
049    import java.util.Collections;
050    import java.util.List;
051    import java.util.Set;
052    
053    /**
054     * The persistence implementation for the user notification event service.
055     *
056     * <p>
057     * Caching information and settings can be found in <code>portal.properties</code>
058     * </p>
059     *
060     * @author Brian Wing Shun Chan
061     * @see UserNotificationEventPersistence
062     * @see UserNotificationEventUtil
063     * @generated
064     */
065    public class UserNotificationEventPersistenceImpl extends BasePersistenceImpl<UserNotificationEvent>
066            implements UserNotificationEventPersistence {
067            /*
068             * NOTE FOR DEVELOPERS:
069             *
070             * Never modify or reference this class directly. Always use {@link UserNotificationEventUtil} to access the user notification event persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
071             */
072            public static final String FINDER_CLASS_NAME_ENTITY = UserNotificationEventImpl.class.getName();
073            public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
074                    ".List1";
075            public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
076                    ".List2";
077            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
078                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
079                            UserNotificationEventImpl.class,
080                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
081            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
082                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
083                            UserNotificationEventImpl.class,
084                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
085            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
086                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED, Long.class,
087                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
088            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
089                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
090                            UserNotificationEventImpl.class,
091                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
092                            new String[] {
093                                    String.class.getName(),
094                                    
095                            Integer.class.getName(), Integer.class.getName(),
096                                    OrderByComparator.class.getName()
097                            });
098            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
099                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
100                            UserNotificationEventImpl.class,
101                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
102                            new String[] { String.class.getName() },
103                            UserNotificationEventModelImpl.UUID_COLUMN_BITMASK |
104                            UserNotificationEventModelImpl.TIMESTAMP_COLUMN_BITMASK);
105            public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
106                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED, Long.class,
107                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
108                            new String[] { String.class.getName() });
109    
110            /**
111             * Returns all the user notification events where uuid = &#63;.
112             *
113             * @param uuid the uuid
114             * @return the matching user notification events
115             * @throws SystemException if a system exception occurred
116             */
117            @Override
118            public List<UserNotificationEvent> findByUuid(String uuid)
119                    throws SystemException {
120                    return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
121            }
122    
123            /**
124             * Returns a range of all the user notification events where uuid = &#63;.
125             *
126             * <p>
127             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
128             * </p>
129             *
130             * @param uuid the uuid
131             * @param start the lower bound of the range of user notification events
132             * @param end the upper bound of the range of user notification events (not inclusive)
133             * @return the range of matching user notification events
134             * @throws SystemException if a system exception occurred
135             */
136            @Override
137            public List<UserNotificationEvent> findByUuid(String uuid, int start,
138                    int end) throws SystemException {
139                    return findByUuid(uuid, start, end, null);
140            }
141    
142            /**
143             * Returns an ordered range of all the user notification events where uuid = &#63;.
144             *
145             * <p>
146             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
147             * </p>
148             *
149             * @param uuid the uuid
150             * @param start the lower bound of the range of user notification events
151             * @param end the upper bound of the range of user notification events (not inclusive)
152             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
153             * @return the ordered range of matching user notification events
154             * @throws SystemException if a system exception occurred
155             */
156            @Override
157            public List<UserNotificationEvent> findByUuid(String uuid, int start,
158                    int end, OrderByComparator orderByComparator) throws SystemException {
159                    boolean pagination = true;
160                    FinderPath finderPath = null;
161                    Object[] finderArgs = null;
162    
163                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
164                                    (orderByComparator == null)) {
165                            pagination = false;
166                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
167                            finderArgs = new Object[] { uuid };
168                    }
169                    else {
170                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
171                            finderArgs = new Object[] { uuid, start, end, orderByComparator };
172                    }
173    
174                    List<UserNotificationEvent> list = (List<UserNotificationEvent>)FinderCacheUtil.getResult(finderPath,
175                                    finderArgs, this);
176    
177                    if ((list != null) && !list.isEmpty()) {
178                            for (UserNotificationEvent userNotificationEvent : list) {
179                                    if (!Validator.equals(uuid, userNotificationEvent.getUuid())) {
180                                            list = null;
181    
182                                            break;
183                                    }
184                            }
185                    }
186    
187                    if (list == null) {
188                            StringBundler query = null;
189    
190                            if (orderByComparator != null) {
191                                    query = new StringBundler(3 +
192                                                    (orderByComparator.getOrderByFields().length * 3));
193                            }
194                            else {
195                                    query = new StringBundler(3);
196                            }
197    
198                            query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
199    
200                            boolean bindUuid = false;
201    
202                            if (uuid == null) {
203                                    query.append(_FINDER_COLUMN_UUID_UUID_1);
204                            }
205                            else if (uuid.equals(StringPool.BLANK)) {
206                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
207                            }
208                            else {
209                                    bindUuid = true;
210    
211                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
212                            }
213    
214                            if (orderByComparator != null) {
215                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
216                                            orderByComparator);
217                            }
218                            else
219                             if (pagination) {
220                                    query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
221                            }
222    
223                            String sql = query.toString();
224    
225                            Session session = null;
226    
227                            try {
228                                    session = openSession();
229    
230                                    Query q = session.createQuery(sql);
231    
232                                    QueryPos qPos = QueryPos.getInstance(q);
233    
234                                    if (bindUuid) {
235                                            qPos.add(uuid);
236                                    }
237    
238                                    if (!pagination) {
239                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
240                                                            getDialect(), start, end, false);
241    
242                                            Collections.sort(list);
243    
244                                            list = new UnmodifiableList<UserNotificationEvent>(list);
245                                    }
246                                    else {
247                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
248                                                            getDialect(), start, end);
249                                    }
250    
251                                    cacheResult(list);
252    
253                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
254                            }
255                            catch (Exception e) {
256                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
257    
258                                    throw processException(e);
259                            }
260                            finally {
261                                    closeSession(session);
262                            }
263                    }
264    
265                    return list;
266            }
267    
268            /**
269             * Returns the first user notification event in the ordered set where uuid = &#63;.
270             *
271             * @param uuid the uuid
272             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
273             * @return the first matching user notification event
274             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
275             * @throws SystemException if a system exception occurred
276             */
277            @Override
278            public UserNotificationEvent findByUuid_First(String uuid,
279                    OrderByComparator orderByComparator)
280                    throws NoSuchUserNotificationEventException, SystemException {
281                    UserNotificationEvent userNotificationEvent = fetchByUuid_First(uuid,
282                                    orderByComparator);
283    
284                    if (userNotificationEvent != null) {
285                            return userNotificationEvent;
286                    }
287    
288                    StringBundler msg = new StringBundler(4);
289    
290                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
291    
292                    msg.append("uuid=");
293                    msg.append(uuid);
294    
295                    msg.append(StringPool.CLOSE_CURLY_BRACE);
296    
297                    throw new NoSuchUserNotificationEventException(msg.toString());
298            }
299    
300            /**
301             * Returns the first user notification event in the ordered set where uuid = &#63;.
302             *
303             * @param uuid the uuid
304             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
305             * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
306             * @throws SystemException if a system exception occurred
307             */
308            @Override
309            public UserNotificationEvent fetchByUuid_First(String uuid,
310                    OrderByComparator orderByComparator) throws SystemException {
311                    List<UserNotificationEvent> list = findByUuid(uuid, 0, 1,
312                                    orderByComparator);
313    
314                    if (!list.isEmpty()) {
315                            return list.get(0);
316                    }
317    
318                    return null;
319            }
320    
321            /**
322             * Returns the last user notification event in the ordered set where uuid = &#63;.
323             *
324             * @param uuid the uuid
325             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
326             * @return the last matching user notification event
327             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
328             * @throws SystemException if a system exception occurred
329             */
330            @Override
331            public UserNotificationEvent findByUuid_Last(String uuid,
332                    OrderByComparator orderByComparator)
333                    throws NoSuchUserNotificationEventException, SystemException {
334                    UserNotificationEvent userNotificationEvent = fetchByUuid_Last(uuid,
335                                    orderByComparator);
336    
337                    if (userNotificationEvent != null) {
338                            return userNotificationEvent;
339                    }
340    
341                    StringBundler msg = new StringBundler(4);
342    
343                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
344    
345                    msg.append("uuid=");
346                    msg.append(uuid);
347    
348                    msg.append(StringPool.CLOSE_CURLY_BRACE);
349    
350                    throw new NoSuchUserNotificationEventException(msg.toString());
351            }
352    
353            /**
354             * Returns the last user notification event in the ordered set where uuid = &#63;.
355             *
356             * @param uuid the uuid
357             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
358             * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
359             * @throws SystemException if a system exception occurred
360             */
361            @Override
362            public UserNotificationEvent fetchByUuid_Last(String uuid,
363                    OrderByComparator orderByComparator) throws SystemException {
364                    int count = countByUuid(uuid);
365    
366                    if (count == 0) {
367                            return null;
368                    }
369    
370                    List<UserNotificationEvent> list = findByUuid(uuid, count - 1, count,
371                                    orderByComparator);
372    
373                    if (!list.isEmpty()) {
374                            return list.get(0);
375                    }
376    
377                    return null;
378            }
379    
380            /**
381             * Returns the user notification events before and after the current user notification event in the ordered set where uuid = &#63;.
382             *
383             * @param userNotificationEventId the primary key of the current user notification event
384             * @param uuid the uuid
385             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
386             * @return the previous, current, and next user notification event
387             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
388             * @throws SystemException if a system exception occurred
389             */
390            @Override
391            public UserNotificationEvent[] findByUuid_PrevAndNext(
392                    long userNotificationEventId, String uuid,
393                    OrderByComparator orderByComparator)
394                    throws NoSuchUserNotificationEventException, SystemException {
395                    UserNotificationEvent userNotificationEvent = findByPrimaryKey(userNotificationEventId);
396    
397                    Session session = null;
398    
399                    try {
400                            session = openSession();
401    
402                            UserNotificationEvent[] array = new UserNotificationEventImpl[3];
403    
404                            array[0] = getByUuid_PrevAndNext(session, userNotificationEvent,
405                                            uuid, orderByComparator, true);
406    
407                            array[1] = userNotificationEvent;
408    
409                            array[2] = getByUuid_PrevAndNext(session, userNotificationEvent,
410                                            uuid, orderByComparator, false);
411    
412                            return array;
413                    }
414                    catch (Exception e) {
415                            throw processException(e);
416                    }
417                    finally {
418                            closeSession(session);
419                    }
420            }
421    
422            protected UserNotificationEvent getByUuid_PrevAndNext(Session session,
423                    UserNotificationEvent userNotificationEvent, String uuid,
424                    OrderByComparator orderByComparator, boolean previous) {
425                    StringBundler query = null;
426    
427                    if (orderByComparator != null) {
428                            query = new StringBundler(6 +
429                                            (orderByComparator.getOrderByFields().length * 6));
430                    }
431                    else {
432                            query = new StringBundler(3);
433                    }
434    
435                    query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
436    
437                    boolean bindUuid = false;
438    
439                    if (uuid == null) {
440                            query.append(_FINDER_COLUMN_UUID_UUID_1);
441                    }
442                    else if (uuid.equals(StringPool.BLANK)) {
443                            query.append(_FINDER_COLUMN_UUID_UUID_3);
444                    }
445                    else {
446                            bindUuid = true;
447    
448                            query.append(_FINDER_COLUMN_UUID_UUID_2);
449                    }
450    
451                    if (orderByComparator != null) {
452                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
453    
454                            if (orderByConditionFields.length > 0) {
455                                    query.append(WHERE_AND);
456                            }
457    
458                            for (int i = 0; i < orderByConditionFields.length; i++) {
459                                    query.append(_ORDER_BY_ENTITY_ALIAS);
460                                    query.append(orderByConditionFields[i]);
461    
462                                    if ((i + 1) < orderByConditionFields.length) {
463                                            if (orderByComparator.isAscending() ^ previous) {
464                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
465                                            }
466                                            else {
467                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
468                                            }
469                                    }
470                                    else {
471                                            if (orderByComparator.isAscending() ^ previous) {
472                                                    query.append(WHERE_GREATER_THAN);
473                                            }
474                                            else {
475                                                    query.append(WHERE_LESSER_THAN);
476                                            }
477                                    }
478                            }
479    
480                            query.append(ORDER_BY_CLAUSE);
481    
482                            String[] orderByFields = orderByComparator.getOrderByFields();
483    
484                            for (int i = 0; i < orderByFields.length; i++) {
485                                    query.append(_ORDER_BY_ENTITY_ALIAS);
486                                    query.append(orderByFields[i]);
487    
488                                    if ((i + 1) < orderByFields.length) {
489                                            if (orderByComparator.isAscending() ^ previous) {
490                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
491                                            }
492                                            else {
493                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
494                                            }
495                                    }
496                                    else {
497                                            if (orderByComparator.isAscending() ^ previous) {
498                                                    query.append(ORDER_BY_ASC);
499                                            }
500                                            else {
501                                                    query.append(ORDER_BY_DESC);
502                                            }
503                                    }
504                            }
505                    }
506                    else {
507                            query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
508                    }
509    
510                    String sql = query.toString();
511    
512                    Query q = session.createQuery(sql);
513    
514                    q.setFirstResult(0);
515                    q.setMaxResults(2);
516    
517                    QueryPos qPos = QueryPos.getInstance(q);
518    
519                    if (bindUuid) {
520                            qPos.add(uuid);
521                    }
522    
523                    if (orderByComparator != null) {
524                            Object[] values = orderByComparator.getOrderByConditionValues(userNotificationEvent);
525    
526                            for (Object value : values) {
527                                    qPos.add(value);
528                            }
529                    }
530    
531                    List<UserNotificationEvent> list = q.list();
532    
533                    if (list.size() == 2) {
534                            return list.get(1);
535                    }
536                    else {
537                            return null;
538                    }
539            }
540    
541            /**
542             * Removes all the user notification events where uuid = &#63; from the database.
543             *
544             * @param uuid the uuid
545             * @throws SystemException if a system exception occurred
546             */
547            @Override
548            public void removeByUuid(String uuid) throws SystemException {
549                    for (UserNotificationEvent userNotificationEvent : findByUuid(uuid,
550                                    QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
551                            remove(userNotificationEvent);
552                    }
553            }
554    
555            /**
556             * Returns the number of user notification events where uuid = &#63;.
557             *
558             * @param uuid the uuid
559             * @return the number of matching user notification events
560             * @throws SystemException if a system exception occurred
561             */
562            @Override
563            public int countByUuid(String uuid) throws SystemException {
564                    FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
565    
566                    Object[] finderArgs = new Object[] { uuid };
567    
568                    Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
569                                    this);
570    
571                    if (count == null) {
572                            StringBundler query = new StringBundler(2);
573    
574                            query.append(_SQL_COUNT_USERNOTIFICATIONEVENT_WHERE);
575    
576                            boolean bindUuid = false;
577    
578                            if (uuid == null) {
579                                    query.append(_FINDER_COLUMN_UUID_UUID_1);
580                            }
581                            else if (uuid.equals(StringPool.BLANK)) {
582                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
583                            }
584                            else {
585                                    bindUuid = true;
586    
587                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
588                            }
589    
590                            String sql = query.toString();
591    
592                            Session session = null;
593    
594                            try {
595                                    session = openSession();
596    
597                                    Query q = session.createQuery(sql);
598    
599                                    QueryPos qPos = QueryPos.getInstance(q);
600    
601                                    if (bindUuid) {
602                                            qPos.add(uuid);
603                                    }
604    
605                                    count = (Long)q.uniqueResult();
606    
607                                    FinderCacheUtil.putResult(finderPath, finderArgs, count);
608                            }
609                            catch (Exception e) {
610                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
611    
612                                    throw processException(e);
613                            }
614                            finally {
615                                    closeSession(session);
616                            }
617                    }
618    
619                    return count.intValue();
620            }
621    
622            private static final String _FINDER_COLUMN_UUID_UUID_1 = "userNotificationEvent.uuid IS NULL";
623            private static final String _FINDER_COLUMN_UUID_UUID_2 = "userNotificationEvent.uuid = ?";
624            private static final String _FINDER_COLUMN_UUID_UUID_3 = "(userNotificationEvent.uuid IS NULL OR userNotificationEvent.uuid = '')";
625            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
626                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
627                            UserNotificationEventImpl.class,
628                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid_C",
629                            new String[] {
630                                    String.class.getName(), Long.class.getName(),
631                                    
632                            Integer.class.getName(), Integer.class.getName(),
633                                    OrderByComparator.class.getName()
634                            });
635            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C =
636                    new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
637                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
638                            UserNotificationEventImpl.class,
639                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid_C",
640                            new String[] { String.class.getName(), Long.class.getName() },
641                            UserNotificationEventModelImpl.UUID_COLUMN_BITMASK |
642                            UserNotificationEventModelImpl.COMPANYID_COLUMN_BITMASK |
643                            UserNotificationEventModelImpl.TIMESTAMP_COLUMN_BITMASK);
644            public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
645                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED, Long.class,
646                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
647                            new String[] { String.class.getName(), Long.class.getName() });
648    
649            /**
650             * Returns all the user notification events where uuid = &#63; and companyId = &#63;.
651             *
652             * @param uuid the uuid
653             * @param companyId the company ID
654             * @return the matching user notification events
655             * @throws SystemException if a system exception occurred
656             */
657            @Override
658            public List<UserNotificationEvent> findByUuid_C(String uuid, long companyId)
659                    throws SystemException {
660                    return findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
661                            QueryUtil.ALL_POS, null);
662            }
663    
664            /**
665             * Returns a range of all the user notification events where uuid = &#63; and companyId = &#63;.
666             *
667             * <p>
668             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
669             * </p>
670             *
671             * @param uuid the uuid
672             * @param companyId the company ID
673             * @param start the lower bound of the range of user notification events
674             * @param end the upper bound of the range of user notification events (not inclusive)
675             * @return the range of matching user notification events
676             * @throws SystemException if a system exception occurred
677             */
678            @Override
679            public List<UserNotificationEvent> findByUuid_C(String uuid,
680                    long companyId, int start, int end) throws SystemException {
681                    return findByUuid_C(uuid, companyId, start, end, null);
682            }
683    
684            /**
685             * Returns an ordered range of all the user notification events where uuid = &#63; and companyId = &#63;.
686             *
687             * <p>
688             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
689             * </p>
690             *
691             * @param uuid the uuid
692             * @param companyId the company ID
693             * @param start the lower bound of the range of user notification events
694             * @param end the upper bound of the range of user notification events (not inclusive)
695             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
696             * @return the ordered range of matching user notification events
697             * @throws SystemException if a system exception occurred
698             */
699            @Override
700            public List<UserNotificationEvent> findByUuid_C(String uuid,
701                    long companyId, int start, int end, OrderByComparator orderByComparator)
702                    throws SystemException {
703                    boolean pagination = true;
704                    FinderPath finderPath = null;
705                    Object[] finderArgs = null;
706    
707                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
708                                    (orderByComparator == null)) {
709                            pagination = false;
710                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C;
711                            finderArgs = new Object[] { uuid, companyId };
712                    }
713                    else {
714                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C;
715                            finderArgs = new Object[] {
716                                            uuid, companyId,
717                                            
718                                            start, end, orderByComparator
719                                    };
720                    }
721    
722                    List<UserNotificationEvent> list = (List<UserNotificationEvent>)FinderCacheUtil.getResult(finderPath,
723                                    finderArgs, this);
724    
725                    if ((list != null) && !list.isEmpty()) {
726                            for (UserNotificationEvent userNotificationEvent : list) {
727                                    if (!Validator.equals(uuid, userNotificationEvent.getUuid()) ||
728                                                    (companyId != userNotificationEvent.getCompanyId())) {
729                                            list = null;
730    
731                                            break;
732                                    }
733                            }
734                    }
735    
736                    if (list == null) {
737                            StringBundler query = null;
738    
739                            if (orderByComparator != null) {
740                                    query = new StringBundler(4 +
741                                                    (orderByComparator.getOrderByFields().length * 3));
742                            }
743                            else {
744                                    query = new StringBundler(4);
745                            }
746    
747                            query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
748    
749                            boolean bindUuid = false;
750    
751                            if (uuid == null) {
752                                    query.append(_FINDER_COLUMN_UUID_C_UUID_1);
753                            }
754                            else if (uuid.equals(StringPool.BLANK)) {
755                                    query.append(_FINDER_COLUMN_UUID_C_UUID_3);
756                            }
757                            else {
758                                    bindUuid = true;
759    
760                                    query.append(_FINDER_COLUMN_UUID_C_UUID_2);
761                            }
762    
763                            query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
764    
765                            if (orderByComparator != null) {
766                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
767                                            orderByComparator);
768                            }
769                            else
770                             if (pagination) {
771                                    query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
772                            }
773    
774                            String sql = query.toString();
775    
776                            Session session = null;
777    
778                            try {
779                                    session = openSession();
780    
781                                    Query q = session.createQuery(sql);
782    
783                                    QueryPos qPos = QueryPos.getInstance(q);
784    
785                                    if (bindUuid) {
786                                            qPos.add(uuid);
787                                    }
788    
789                                    qPos.add(companyId);
790    
791                                    if (!pagination) {
792                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
793                                                            getDialect(), start, end, false);
794    
795                                            Collections.sort(list);
796    
797                                            list = new UnmodifiableList<UserNotificationEvent>(list);
798                                    }
799                                    else {
800                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
801                                                            getDialect(), start, end);
802                                    }
803    
804                                    cacheResult(list);
805    
806                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
807                            }
808                            catch (Exception e) {
809                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
810    
811                                    throw processException(e);
812                            }
813                            finally {
814                                    closeSession(session);
815                            }
816                    }
817    
818                    return list;
819            }
820    
821            /**
822             * Returns the first user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
823             *
824             * @param uuid the uuid
825             * @param companyId the company ID
826             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
827             * @return the first matching user notification event
828             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
829             * @throws SystemException if a system exception occurred
830             */
831            @Override
832            public UserNotificationEvent findByUuid_C_First(String uuid,
833                    long companyId, OrderByComparator orderByComparator)
834                    throws NoSuchUserNotificationEventException, SystemException {
835                    UserNotificationEvent userNotificationEvent = fetchByUuid_C_First(uuid,
836                                    companyId, orderByComparator);
837    
838                    if (userNotificationEvent != null) {
839                            return userNotificationEvent;
840                    }
841    
842                    StringBundler msg = new StringBundler(6);
843    
844                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
845    
846                    msg.append("uuid=");
847                    msg.append(uuid);
848    
849                    msg.append(", companyId=");
850                    msg.append(companyId);
851    
852                    msg.append(StringPool.CLOSE_CURLY_BRACE);
853    
854                    throw new NoSuchUserNotificationEventException(msg.toString());
855            }
856    
857            /**
858             * Returns the first user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
859             *
860             * @param uuid the uuid
861             * @param companyId the company ID
862             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
863             * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
864             * @throws SystemException if a system exception occurred
865             */
866            @Override
867            public UserNotificationEvent fetchByUuid_C_First(String uuid,
868                    long companyId, OrderByComparator orderByComparator)
869                    throws SystemException {
870                    List<UserNotificationEvent> list = findByUuid_C(uuid, companyId, 0, 1,
871                                    orderByComparator);
872    
873                    if (!list.isEmpty()) {
874                            return list.get(0);
875                    }
876    
877                    return null;
878            }
879    
880            /**
881             * Returns the last user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
882             *
883             * @param uuid the uuid
884             * @param companyId the company ID
885             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
886             * @return the last matching user notification event
887             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
888             * @throws SystemException if a system exception occurred
889             */
890            @Override
891            public UserNotificationEvent findByUuid_C_Last(String uuid, long companyId,
892                    OrderByComparator orderByComparator)
893                    throws NoSuchUserNotificationEventException, SystemException {
894                    UserNotificationEvent userNotificationEvent = fetchByUuid_C_Last(uuid,
895                                    companyId, orderByComparator);
896    
897                    if (userNotificationEvent != null) {
898                            return userNotificationEvent;
899                    }
900    
901                    StringBundler msg = new StringBundler(6);
902    
903                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
904    
905                    msg.append("uuid=");
906                    msg.append(uuid);
907    
908                    msg.append(", companyId=");
909                    msg.append(companyId);
910    
911                    msg.append(StringPool.CLOSE_CURLY_BRACE);
912    
913                    throw new NoSuchUserNotificationEventException(msg.toString());
914            }
915    
916            /**
917             * Returns the last user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
918             *
919             * @param uuid the uuid
920             * @param companyId the company ID
921             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
922             * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
923             * @throws SystemException if a system exception occurred
924             */
925            @Override
926            public UserNotificationEvent fetchByUuid_C_Last(String uuid,
927                    long companyId, OrderByComparator orderByComparator)
928                    throws SystemException {
929                    int count = countByUuid_C(uuid, companyId);
930    
931                    if (count == 0) {
932                            return null;
933                    }
934    
935                    List<UserNotificationEvent> list = findByUuid_C(uuid, companyId,
936                                    count - 1, count, orderByComparator);
937    
938                    if (!list.isEmpty()) {
939                            return list.get(0);
940                    }
941    
942                    return null;
943            }
944    
945            /**
946             * Returns the user notification events before and after the current user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
947             *
948             * @param userNotificationEventId the primary key of the current user notification event
949             * @param uuid the uuid
950             * @param companyId the company ID
951             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
952             * @return the previous, current, and next user notification event
953             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
954             * @throws SystemException if a system exception occurred
955             */
956            @Override
957            public UserNotificationEvent[] findByUuid_C_PrevAndNext(
958                    long userNotificationEventId, String uuid, long companyId,
959                    OrderByComparator orderByComparator)
960                    throws NoSuchUserNotificationEventException, SystemException {
961                    UserNotificationEvent userNotificationEvent = findByPrimaryKey(userNotificationEventId);
962    
963                    Session session = null;
964    
965                    try {
966                            session = openSession();
967    
968                            UserNotificationEvent[] array = new UserNotificationEventImpl[3];
969    
970                            array[0] = getByUuid_C_PrevAndNext(session, userNotificationEvent,
971                                            uuid, companyId, orderByComparator, true);
972    
973                            array[1] = userNotificationEvent;
974    
975                            array[2] = getByUuid_C_PrevAndNext(session, userNotificationEvent,
976                                            uuid, companyId, orderByComparator, false);
977    
978                            return array;
979                    }
980                    catch (Exception e) {
981                            throw processException(e);
982                    }
983                    finally {
984                            closeSession(session);
985                    }
986            }
987    
988            protected UserNotificationEvent getByUuid_C_PrevAndNext(Session session,
989                    UserNotificationEvent userNotificationEvent, String uuid,
990                    long companyId, OrderByComparator orderByComparator, boolean previous) {
991                    StringBundler query = null;
992    
993                    if (orderByComparator != null) {
994                            query = new StringBundler(6 +
995                                            (orderByComparator.getOrderByFields().length * 6));
996                    }
997                    else {
998                            query = new StringBundler(3);
999                    }
1000    
1001                    query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
1002    
1003                    boolean bindUuid = false;
1004    
1005                    if (uuid == null) {
1006                            query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1007                    }
1008                    else if (uuid.equals(StringPool.BLANK)) {
1009                            query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1010                    }
1011                    else {
1012                            bindUuid = true;
1013    
1014                            query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1015                    }
1016    
1017                    query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1018    
1019                    if (orderByComparator != null) {
1020                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1021    
1022                            if (orderByConditionFields.length > 0) {
1023                                    query.append(WHERE_AND);
1024                            }
1025    
1026                            for (int i = 0; i < orderByConditionFields.length; i++) {
1027                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1028                                    query.append(orderByConditionFields[i]);
1029    
1030                                    if ((i + 1) < orderByConditionFields.length) {
1031                                            if (orderByComparator.isAscending() ^ previous) {
1032                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1033                                            }
1034                                            else {
1035                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1036                                            }
1037                                    }
1038                                    else {
1039                                            if (orderByComparator.isAscending() ^ previous) {
1040                                                    query.append(WHERE_GREATER_THAN);
1041                                            }
1042                                            else {
1043                                                    query.append(WHERE_LESSER_THAN);
1044                                            }
1045                                    }
1046                            }
1047    
1048                            query.append(ORDER_BY_CLAUSE);
1049    
1050                            String[] orderByFields = orderByComparator.getOrderByFields();
1051    
1052                            for (int i = 0; i < orderByFields.length; i++) {
1053                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1054                                    query.append(orderByFields[i]);
1055    
1056                                    if ((i + 1) < orderByFields.length) {
1057                                            if (orderByComparator.isAscending() ^ previous) {
1058                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1059                                            }
1060                                            else {
1061                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1062                                            }
1063                                    }
1064                                    else {
1065                                            if (orderByComparator.isAscending() ^ previous) {
1066                                                    query.append(ORDER_BY_ASC);
1067                                            }
1068                                            else {
1069                                                    query.append(ORDER_BY_DESC);
1070                                            }
1071                                    }
1072                            }
1073                    }
1074                    else {
1075                            query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
1076                    }
1077    
1078                    String sql = query.toString();
1079    
1080                    Query q = session.createQuery(sql);
1081    
1082                    q.setFirstResult(0);
1083                    q.setMaxResults(2);
1084    
1085                    QueryPos qPos = QueryPos.getInstance(q);
1086    
1087                    if (bindUuid) {
1088                            qPos.add(uuid);
1089                    }
1090    
1091                    qPos.add(companyId);
1092    
1093                    if (orderByComparator != null) {
1094                            Object[] values = orderByComparator.getOrderByConditionValues(userNotificationEvent);
1095    
1096                            for (Object value : values) {
1097                                    qPos.add(value);
1098                            }
1099                    }
1100    
1101                    List<UserNotificationEvent> list = q.list();
1102    
1103                    if (list.size() == 2) {
1104                            return list.get(1);
1105                    }
1106                    else {
1107                            return null;
1108                    }
1109            }
1110    
1111            /**
1112             * Removes all the user notification events where uuid = &#63; and companyId = &#63; from the database.
1113             *
1114             * @param uuid the uuid
1115             * @param companyId the company ID
1116             * @throws SystemException if a system exception occurred
1117             */
1118            @Override
1119            public void removeByUuid_C(String uuid, long companyId)
1120                    throws SystemException {
1121                    for (UserNotificationEvent userNotificationEvent : findByUuid_C(uuid,
1122                                    companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1123                            remove(userNotificationEvent);
1124                    }
1125            }
1126    
1127            /**
1128             * Returns the number of user notification events where uuid = &#63; and companyId = &#63;.
1129             *
1130             * @param uuid the uuid
1131             * @param companyId the company ID
1132             * @return the number of matching user notification events
1133             * @throws SystemException if a system exception occurred
1134             */
1135            @Override
1136            public int countByUuid_C(String uuid, long companyId)
1137                    throws SystemException {
1138                    FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_C;
1139    
1140                    Object[] finderArgs = new Object[] { uuid, companyId };
1141    
1142                    Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1143                                    this);
1144    
1145                    if (count == null) {
1146                            StringBundler query = new StringBundler(3);
1147    
1148                            query.append(_SQL_COUNT_USERNOTIFICATIONEVENT_WHERE);
1149    
1150                            boolean bindUuid = false;
1151    
1152                            if (uuid == null) {
1153                                    query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1154                            }
1155                            else if (uuid.equals(StringPool.BLANK)) {
1156                                    query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1157                            }
1158                            else {
1159                                    bindUuid = true;
1160    
1161                                    query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1162                            }
1163    
1164                            query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1165    
1166                            String sql = query.toString();
1167    
1168                            Session session = null;
1169    
1170                            try {
1171                                    session = openSession();
1172    
1173                                    Query q = session.createQuery(sql);
1174    
1175                                    QueryPos qPos = QueryPos.getInstance(q);
1176    
1177                                    if (bindUuid) {
1178                                            qPos.add(uuid);
1179                                    }
1180    
1181                                    qPos.add(companyId);
1182    
1183                                    count = (Long)q.uniqueResult();
1184    
1185                                    FinderCacheUtil.putResult(finderPath, finderArgs, count);
1186                            }
1187                            catch (Exception e) {
1188                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
1189    
1190                                    throw processException(e);
1191                            }
1192                            finally {
1193                                    closeSession(session);
1194                            }
1195                    }
1196    
1197                    return count.intValue();
1198            }
1199    
1200            private static final String _FINDER_COLUMN_UUID_C_UUID_1 = "userNotificationEvent.uuid IS NULL AND ";
1201            private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "userNotificationEvent.uuid = ? AND ";
1202            private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(userNotificationEvent.uuid IS NULL OR userNotificationEvent.uuid = '') AND ";
1203            private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "userNotificationEvent.companyId = ?";
1204            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
1205                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
1206                            UserNotificationEventImpl.class,
1207                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUserId",
1208                            new String[] {
1209                                    Long.class.getName(),
1210                                    
1211                            Integer.class.getName(), Integer.class.getName(),
1212                                    OrderByComparator.class.getName()
1213                            });
1214            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID =
1215                    new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
1216                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
1217                            UserNotificationEventImpl.class,
1218                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUserId",
1219                            new String[] { Long.class.getName() },
1220                            UserNotificationEventModelImpl.USERID_COLUMN_BITMASK |
1221                            UserNotificationEventModelImpl.TIMESTAMP_COLUMN_BITMASK);
1222            public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
1223                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED, Long.class,
1224                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUserId",
1225                            new String[] { Long.class.getName() });
1226    
1227            /**
1228             * Returns all the user notification events where userId = &#63;.
1229             *
1230             * @param userId the user ID
1231             * @return the matching user notification events
1232             * @throws SystemException if a system exception occurred
1233             */
1234            @Override
1235            public List<UserNotificationEvent> findByUserId(long userId)
1236                    throws SystemException {
1237                    return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1238            }
1239    
1240            /**
1241             * Returns a range of all the user notification events where userId = &#63;.
1242             *
1243             * <p>
1244             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
1245             * </p>
1246             *
1247             * @param userId the user ID
1248             * @param start the lower bound of the range of user notification events
1249             * @param end the upper bound of the range of user notification events (not inclusive)
1250             * @return the range of matching user notification events
1251             * @throws SystemException if a system exception occurred
1252             */
1253            @Override
1254            public List<UserNotificationEvent> findByUserId(long userId, int start,
1255                    int end) throws SystemException {
1256                    return findByUserId(userId, start, end, null);
1257            }
1258    
1259            /**
1260             * Returns an ordered range of all the user notification events where userId = &#63;.
1261             *
1262             * <p>
1263             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
1264             * </p>
1265             *
1266             * @param userId the user ID
1267             * @param start the lower bound of the range of user notification events
1268             * @param end the upper bound of the range of user notification events (not inclusive)
1269             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1270             * @return the ordered range of matching user notification events
1271             * @throws SystemException if a system exception occurred
1272             */
1273            @Override
1274            public List<UserNotificationEvent> findByUserId(long userId, int start,
1275                    int end, OrderByComparator orderByComparator) throws SystemException {
1276                    boolean pagination = true;
1277                    FinderPath finderPath = null;
1278                    Object[] finderArgs = null;
1279    
1280                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1281                                    (orderByComparator == null)) {
1282                            pagination = false;
1283                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID;
1284                            finderArgs = new Object[] { userId };
1285                    }
1286                    else {
1287                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID;
1288                            finderArgs = new Object[] { userId, start, end, orderByComparator };
1289                    }
1290    
1291                    List<UserNotificationEvent> list = (List<UserNotificationEvent>)FinderCacheUtil.getResult(finderPath,
1292                                    finderArgs, this);
1293    
1294                    if ((list != null) && !list.isEmpty()) {
1295                            for (UserNotificationEvent userNotificationEvent : list) {
1296                                    if ((userId != userNotificationEvent.getUserId())) {
1297                                            list = null;
1298    
1299                                            break;
1300                                    }
1301                            }
1302                    }
1303    
1304                    if (list == null) {
1305                            StringBundler query = null;
1306    
1307                            if (orderByComparator != null) {
1308                                    query = new StringBundler(3 +
1309                                                    (orderByComparator.getOrderByFields().length * 3));
1310                            }
1311                            else {
1312                                    query = new StringBundler(3);
1313                            }
1314    
1315                            query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
1316    
1317                            query.append(_FINDER_COLUMN_USERID_USERID_2);
1318    
1319                            if (orderByComparator != null) {
1320                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1321                                            orderByComparator);
1322                            }
1323                            else
1324                             if (pagination) {
1325                                    query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
1326                            }
1327    
1328                            String sql = query.toString();
1329    
1330                            Session session = null;
1331    
1332                            try {
1333                                    session = openSession();
1334    
1335                                    Query q = session.createQuery(sql);
1336    
1337                                    QueryPos qPos = QueryPos.getInstance(q);
1338    
1339                                    qPos.add(userId);
1340    
1341                                    if (!pagination) {
1342                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
1343                                                            getDialect(), start, end, false);
1344    
1345                                            Collections.sort(list);
1346    
1347                                            list = new UnmodifiableList<UserNotificationEvent>(list);
1348                                    }
1349                                    else {
1350                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
1351                                                            getDialect(), start, end);
1352                                    }
1353    
1354                                    cacheResult(list);
1355    
1356                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
1357                            }
1358                            catch (Exception e) {
1359                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
1360    
1361                                    throw processException(e);
1362                            }
1363                            finally {
1364                                    closeSession(session);
1365                            }
1366                    }
1367    
1368                    return list;
1369            }
1370    
1371            /**
1372             * Returns the first user notification event in the ordered set where userId = &#63;.
1373             *
1374             * @param userId the user ID
1375             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1376             * @return the first matching user notification event
1377             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
1378             * @throws SystemException if a system exception occurred
1379             */
1380            @Override
1381            public UserNotificationEvent findByUserId_First(long userId,
1382                    OrderByComparator orderByComparator)
1383                    throws NoSuchUserNotificationEventException, SystemException {
1384                    UserNotificationEvent userNotificationEvent = fetchByUserId_First(userId,
1385                                    orderByComparator);
1386    
1387                    if (userNotificationEvent != null) {
1388                            return userNotificationEvent;
1389                    }
1390    
1391                    StringBundler msg = new StringBundler(4);
1392    
1393                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1394    
1395                    msg.append("userId=");
1396                    msg.append(userId);
1397    
1398                    msg.append(StringPool.CLOSE_CURLY_BRACE);
1399    
1400                    throw new NoSuchUserNotificationEventException(msg.toString());
1401            }
1402    
1403            /**
1404             * Returns the first user notification event in the ordered set where userId = &#63;.
1405             *
1406             * @param userId the user ID
1407             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1408             * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1409             * @throws SystemException if a system exception occurred
1410             */
1411            @Override
1412            public UserNotificationEvent fetchByUserId_First(long userId,
1413                    OrderByComparator orderByComparator) throws SystemException {
1414                    List<UserNotificationEvent> list = findByUserId(userId, 0, 1,
1415                                    orderByComparator);
1416    
1417                    if (!list.isEmpty()) {
1418                            return list.get(0);
1419                    }
1420    
1421                    return null;
1422            }
1423    
1424            /**
1425             * Returns the last user notification event in the ordered set where userId = &#63;.
1426             *
1427             * @param userId the user ID
1428             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1429             * @return the last matching user notification event
1430             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
1431             * @throws SystemException if a system exception occurred
1432             */
1433            @Override
1434            public UserNotificationEvent findByUserId_Last(long userId,
1435                    OrderByComparator orderByComparator)
1436                    throws NoSuchUserNotificationEventException, SystemException {
1437                    UserNotificationEvent userNotificationEvent = fetchByUserId_Last(userId,
1438                                    orderByComparator);
1439    
1440                    if (userNotificationEvent != null) {
1441                            return userNotificationEvent;
1442                    }
1443    
1444                    StringBundler msg = new StringBundler(4);
1445    
1446                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1447    
1448                    msg.append("userId=");
1449                    msg.append(userId);
1450    
1451                    msg.append(StringPool.CLOSE_CURLY_BRACE);
1452    
1453                    throw new NoSuchUserNotificationEventException(msg.toString());
1454            }
1455    
1456            /**
1457             * Returns the last user notification event in the ordered set where userId = &#63;.
1458             *
1459             * @param userId the user ID
1460             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1461             * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1462             * @throws SystemException if a system exception occurred
1463             */
1464            @Override
1465            public UserNotificationEvent fetchByUserId_Last(long userId,
1466                    OrderByComparator orderByComparator) throws SystemException {
1467                    int count = countByUserId(userId);
1468    
1469                    if (count == 0) {
1470                            return null;
1471                    }
1472    
1473                    List<UserNotificationEvent> list = findByUserId(userId, count - 1,
1474                                    count, orderByComparator);
1475    
1476                    if (!list.isEmpty()) {
1477                            return list.get(0);
1478                    }
1479    
1480                    return null;
1481            }
1482    
1483            /**
1484             * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63;.
1485             *
1486             * @param userNotificationEventId the primary key of the current user notification event
1487             * @param userId the user ID
1488             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1489             * @return the previous, current, and next user notification event
1490             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1491             * @throws SystemException if a system exception occurred
1492             */
1493            @Override
1494            public UserNotificationEvent[] findByUserId_PrevAndNext(
1495                    long userNotificationEventId, long userId,
1496                    OrderByComparator orderByComparator)
1497                    throws NoSuchUserNotificationEventException, SystemException {
1498                    UserNotificationEvent userNotificationEvent = findByPrimaryKey(userNotificationEventId);
1499    
1500                    Session session = null;
1501    
1502                    try {
1503                            session = openSession();
1504    
1505                            UserNotificationEvent[] array = new UserNotificationEventImpl[3];
1506    
1507                            array[0] = getByUserId_PrevAndNext(session, userNotificationEvent,
1508                                            userId, orderByComparator, true);
1509    
1510                            array[1] = userNotificationEvent;
1511    
1512                            array[2] = getByUserId_PrevAndNext(session, userNotificationEvent,
1513                                            userId, orderByComparator, false);
1514    
1515                            return array;
1516                    }
1517                    catch (Exception e) {
1518                            throw processException(e);
1519                    }
1520                    finally {
1521                            closeSession(session);
1522                    }
1523            }
1524    
1525            protected UserNotificationEvent getByUserId_PrevAndNext(Session session,
1526                    UserNotificationEvent userNotificationEvent, long userId,
1527                    OrderByComparator orderByComparator, boolean previous) {
1528                    StringBundler query = null;
1529    
1530                    if (orderByComparator != null) {
1531                            query = new StringBundler(6 +
1532                                            (orderByComparator.getOrderByFields().length * 6));
1533                    }
1534                    else {
1535                            query = new StringBundler(3);
1536                    }
1537    
1538                    query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
1539    
1540                    query.append(_FINDER_COLUMN_USERID_USERID_2);
1541    
1542                    if (orderByComparator != null) {
1543                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1544    
1545                            if (orderByConditionFields.length > 0) {
1546                                    query.append(WHERE_AND);
1547                            }
1548    
1549                            for (int i = 0; i < orderByConditionFields.length; i++) {
1550                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1551                                    query.append(orderByConditionFields[i]);
1552    
1553                                    if ((i + 1) < orderByConditionFields.length) {
1554                                            if (orderByComparator.isAscending() ^ previous) {
1555                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1556                                            }
1557                                            else {
1558                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1559                                            }
1560                                    }
1561                                    else {
1562                                            if (orderByComparator.isAscending() ^ previous) {
1563                                                    query.append(WHERE_GREATER_THAN);
1564                                            }
1565                                            else {
1566                                                    query.append(WHERE_LESSER_THAN);
1567                                            }
1568                                    }
1569                            }
1570    
1571                            query.append(ORDER_BY_CLAUSE);
1572    
1573                            String[] orderByFields = orderByComparator.getOrderByFields();
1574    
1575                            for (int i = 0; i < orderByFields.length; i++) {
1576                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1577                                    query.append(orderByFields[i]);
1578    
1579                                    if ((i + 1) < orderByFields.length) {
1580                                            if (orderByComparator.isAscending() ^ previous) {
1581                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1582                                            }
1583                                            else {
1584                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1585                                            }
1586                                    }
1587                                    else {
1588                                            if (orderByComparator.isAscending() ^ previous) {
1589                                                    query.append(ORDER_BY_ASC);
1590                                            }
1591                                            else {
1592                                                    query.append(ORDER_BY_DESC);
1593                                            }
1594                                    }
1595                            }
1596                    }
1597                    else {
1598                            query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
1599                    }
1600    
1601                    String sql = query.toString();
1602    
1603                    Query q = session.createQuery(sql);
1604    
1605                    q.setFirstResult(0);
1606                    q.setMaxResults(2);
1607    
1608                    QueryPos qPos = QueryPos.getInstance(q);
1609    
1610                    qPos.add(userId);
1611    
1612                    if (orderByComparator != null) {
1613                            Object[] values = orderByComparator.getOrderByConditionValues(userNotificationEvent);
1614    
1615                            for (Object value : values) {
1616                                    qPos.add(value);
1617                            }
1618                    }
1619    
1620                    List<UserNotificationEvent> list = q.list();
1621    
1622                    if (list.size() == 2) {
1623                            return list.get(1);
1624                    }
1625                    else {
1626                            return null;
1627                    }
1628            }
1629    
1630            /**
1631             * Removes all the user notification events where userId = &#63; from the database.
1632             *
1633             * @param userId the user ID
1634             * @throws SystemException if a system exception occurred
1635             */
1636            @Override
1637            public void removeByUserId(long userId) throws SystemException {
1638                    for (UserNotificationEvent userNotificationEvent : findByUserId(
1639                                    userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1640                            remove(userNotificationEvent);
1641                    }
1642            }
1643    
1644            /**
1645             * Returns the number of user notification events where userId = &#63;.
1646             *
1647             * @param userId the user ID
1648             * @return the number of matching user notification events
1649             * @throws SystemException if a system exception occurred
1650             */
1651            @Override
1652            public int countByUserId(long userId) throws SystemException {
1653                    FinderPath finderPath = FINDER_PATH_COUNT_BY_USERID;
1654    
1655                    Object[] finderArgs = new Object[] { userId };
1656    
1657                    Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1658                                    this);
1659    
1660                    if (count == null) {
1661                            StringBundler query = new StringBundler(2);
1662    
1663                            query.append(_SQL_COUNT_USERNOTIFICATIONEVENT_WHERE);
1664    
1665                            query.append(_FINDER_COLUMN_USERID_USERID_2);
1666    
1667                            String sql = query.toString();
1668    
1669                            Session session = null;
1670    
1671                            try {
1672                                    session = openSession();
1673    
1674                                    Query q = session.createQuery(sql);
1675    
1676                                    QueryPos qPos = QueryPos.getInstance(q);
1677    
1678                                    qPos.add(userId);
1679    
1680                                    count = (Long)q.uniqueResult();
1681    
1682                                    FinderCacheUtil.putResult(finderPath, finderArgs, count);
1683                            }
1684                            catch (Exception e) {
1685                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
1686    
1687                                    throw processException(e);
1688                            }
1689                            finally {
1690                                    closeSession(session);
1691                            }
1692                    }
1693    
1694                    return count.intValue();
1695            }
1696    
1697            private static final String _FINDER_COLUMN_USERID_USERID_2 = "userNotificationEvent.userId = ?";
1698            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_U_D = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
1699                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
1700                            UserNotificationEventImpl.class,
1701                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByU_D",
1702                            new String[] {
1703                                    Long.class.getName(), Boolean.class.getName(),
1704                                    
1705                            Integer.class.getName(), Integer.class.getName(),
1706                                    OrderByComparator.class.getName()
1707                            });
1708            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_D = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
1709                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
1710                            UserNotificationEventImpl.class,
1711                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByU_D",
1712                            new String[] { Long.class.getName(), Boolean.class.getName() },
1713                            UserNotificationEventModelImpl.USERID_COLUMN_BITMASK |
1714                            UserNotificationEventModelImpl.DELIVERED_COLUMN_BITMASK |
1715                            UserNotificationEventModelImpl.TIMESTAMP_COLUMN_BITMASK);
1716            public static final FinderPath FINDER_PATH_COUNT_BY_U_D = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
1717                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED, Long.class,
1718                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByU_D",
1719                            new String[] { Long.class.getName(), Boolean.class.getName() });
1720    
1721            /**
1722             * Returns all the user notification events where userId = &#63; and delivered = &#63;.
1723             *
1724             * @param userId the user ID
1725             * @param delivered the delivered
1726             * @return the matching user notification events
1727             * @throws SystemException if a system exception occurred
1728             */
1729            @Override
1730            public List<UserNotificationEvent> findByU_D(long userId, boolean delivered)
1731                    throws SystemException {
1732                    return findByU_D(userId, delivered, QueryUtil.ALL_POS,
1733                            QueryUtil.ALL_POS, null);
1734            }
1735    
1736            /**
1737             * Returns a range of all the user notification events where userId = &#63; and delivered = &#63;.
1738             *
1739             * <p>
1740             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
1741             * </p>
1742             *
1743             * @param userId the user ID
1744             * @param delivered the delivered
1745             * @param start the lower bound of the range of user notification events
1746             * @param end the upper bound of the range of user notification events (not inclusive)
1747             * @return the range of matching user notification events
1748             * @throws SystemException if a system exception occurred
1749             */
1750            @Override
1751            public List<UserNotificationEvent> findByU_D(long userId,
1752                    boolean delivered, int start, int end) throws SystemException {
1753                    return findByU_D(userId, delivered, start, end, null);
1754            }
1755    
1756            /**
1757             * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63;.
1758             *
1759             * <p>
1760             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
1761             * </p>
1762             *
1763             * @param userId the user ID
1764             * @param delivered the delivered
1765             * @param start the lower bound of the range of user notification events
1766             * @param end the upper bound of the range of user notification events (not inclusive)
1767             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1768             * @return the ordered range of matching user notification events
1769             * @throws SystemException if a system exception occurred
1770             */
1771            @Override
1772            public List<UserNotificationEvent> findByU_D(long userId,
1773                    boolean delivered, int start, int end,
1774                    OrderByComparator orderByComparator) throws SystemException {
1775                    boolean pagination = true;
1776                    FinderPath finderPath = null;
1777                    Object[] finderArgs = null;
1778    
1779                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1780                                    (orderByComparator == null)) {
1781                            pagination = false;
1782                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_D;
1783                            finderArgs = new Object[] { userId, delivered };
1784                    }
1785                    else {
1786                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_U_D;
1787                            finderArgs = new Object[] {
1788                                            userId, delivered,
1789                                            
1790                                            start, end, orderByComparator
1791                                    };
1792                    }
1793    
1794                    List<UserNotificationEvent> list = (List<UserNotificationEvent>)FinderCacheUtil.getResult(finderPath,
1795                                    finderArgs, this);
1796    
1797                    if ((list != null) && !list.isEmpty()) {
1798                            for (UserNotificationEvent userNotificationEvent : list) {
1799                                    if ((userId != userNotificationEvent.getUserId()) ||
1800                                                    (delivered != userNotificationEvent.getDelivered())) {
1801                                            list = null;
1802    
1803                                            break;
1804                                    }
1805                            }
1806                    }
1807    
1808                    if (list == null) {
1809                            StringBundler query = null;
1810    
1811                            if (orderByComparator != null) {
1812                                    query = new StringBundler(4 +
1813                                                    (orderByComparator.getOrderByFields().length * 3));
1814                            }
1815                            else {
1816                                    query = new StringBundler(4);
1817                            }
1818    
1819                            query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
1820    
1821                            query.append(_FINDER_COLUMN_U_D_USERID_2);
1822    
1823                            query.append(_FINDER_COLUMN_U_D_DELIVERED_2);
1824    
1825                            if (orderByComparator != null) {
1826                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1827                                            orderByComparator);
1828                            }
1829                            else
1830                             if (pagination) {
1831                                    query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
1832                            }
1833    
1834                            String sql = query.toString();
1835    
1836                            Session session = null;
1837    
1838                            try {
1839                                    session = openSession();
1840    
1841                                    Query q = session.createQuery(sql);
1842    
1843                                    QueryPos qPos = QueryPos.getInstance(q);
1844    
1845                                    qPos.add(userId);
1846    
1847                                    qPos.add(delivered);
1848    
1849                                    if (!pagination) {
1850                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
1851                                                            getDialect(), start, end, false);
1852    
1853                                            Collections.sort(list);
1854    
1855                                            list = new UnmodifiableList<UserNotificationEvent>(list);
1856                                    }
1857                                    else {
1858                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
1859                                                            getDialect(), start, end);
1860                                    }
1861    
1862                                    cacheResult(list);
1863    
1864                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
1865                            }
1866                            catch (Exception e) {
1867                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
1868    
1869                                    throw processException(e);
1870                            }
1871                            finally {
1872                                    closeSession(session);
1873                            }
1874                    }
1875    
1876                    return list;
1877            }
1878    
1879            /**
1880             * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63;.
1881             *
1882             * @param userId the user ID
1883             * @param delivered the delivered
1884             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1885             * @return the first matching user notification event
1886             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
1887             * @throws SystemException if a system exception occurred
1888             */
1889            @Override
1890            public UserNotificationEvent findByU_D_First(long userId,
1891                    boolean delivered, OrderByComparator orderByComparator)
1892                    throws NoSuchUserNotificationEventException, SystemException {
1893                    UserNotificationEvent userNotificationEvent = fetchByU_D_First(userId,
1894                                    delivered, orderByComparator);
1895    
1896                    if (userNotificationEvent != null) {
1897                            return userNotificationEvent;
1898                    }
1899    
1900                    StringBundler msg = new StringBundler(6);
1901    
1902                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1903    
1904                    msg.append("userId=");
1905                    msg.append(userId);
1906    
1907                    msg.append(", delivered=");
1908                    msg.append(delivered);
1909    
1910                    msg.append(StringPool.CLOSE_CURLY_BRACE);
1911    
1912                    throw new NoSuchUserNotificationEventException(msg.toString());
1913            }
1914    
1915            /**
1916             * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63;.
1917             *
1918             * @param userId the user ID
1919             * @param delivered the delivered
1920             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1921             * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1922             * @throws SystemException if a system exception occurred
1923             */
1924            @Override
1925            public UserNotificationEvent fetchByU_D_First(long userId,
1926                    boolean delivered, OrderByComparator orderByComparator)
1927                    throws SystemException {
1928                    List<UserNotificationEvent> list = findByU_D(userId, delivered, 0, 1,
1929                                    orderByComparator);
1930    
1931                    if (!list.isEmpty()) {
1932                            return list.get(0);
1933                    }
1934    
1935                    return null;
1936            }
1937    
1938            /**
1939             * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63;.
1940             *
1941             * @param userId the user ID
1942             * @param delivered the delivered
1943             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1944             * @return the last matching user notification event
1945             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
1946             * @throws SystemException if a system exception occurred
1947             */
1948            @Override
1949            public UserNotificationEvent findByU_D_Last(long userId, boolean delivered,
1950                    OrderByComparator orderByComparator)
1951                    throws NoSuchUserNotificationEventException, SystemException {
1952                    UserNotificationEvent userNotificationEvent = fetchByU_D_Last(userId,
1953                                    delivered, orderByComparator);
1954    
1955                    if (userNotificationEvent != null) {
1956                            return userNotificationEvent;
1957                    }
1958    
1959                    StringBundler msg = new StringBundler(6);
1960    
1961                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1962    
1963                    msg.append("userId=");
1964                    msg.append(userId);
1965    
1966                    msg.append(", delivered=");
1967                    msg.append(delivered);
1968    
1969                    msg.append(StringPool.CLOSE_CURLY_BRACE);
1970    
1971                    throw new NoSuchUserNotificationEventException(msg.toString());
1972            }
1973    
1974            /**
1975             * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63;.
1976             *
1977             * @param userId the user ID
1978             * @param delivered the delivered
1979             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1980             * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1981             * @throws SystemException if a system exception occurred
1982             */
1983            @Override
1984            public UserNotificationEvent fetchByU_D_Last(long userId,
1985                    boolean delivered, OrderByComparator orderByComparator)
1986                    throws SystemException {
1987                    int count = countByU_D(userId, delivered);
1988    
1989                    if (count == 0) {
1990                            return null;
1991                    }
1992    
1993                    List<UserNotificationEvent> list = findByU_D(userId, delivered,
1994                                    count - 1, count, orderByComparator);
1995    
1996                    if (!list.isEmpty()) {
1997                            return list.get(0);
1998                    }
1999    
2000                    return null;
2001            }
2002    
2003            /**
2004             * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and delivered = &#63;.
2005             *
2006             * @param userNotificationEventId the primary key of the current user notification event
2007             * @param userId the user ID
2008             * @param delivered the delivered
2009             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2010             * @return the previous, current, and next user notification event
2011             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2012             * @throws SystemException if a system exception occurred
2013             */
2014            @Override
2015            public UserNotificationEvent[] findByU_D_PrevAndNext(
2016                    long userNotificationEventId, long userId, boolean delivered,
2017                    OrderByComparator orderByComparator)
2018                    throws NoSuchUserNotificationEventException, SystemException {
2019                    UserNotificationEvent userNotificationEvent = findByPrimaryKey(userNotificationEventId);
2020    
2021                    Session session = null;
2022    
2023                    try {
2024                            session = openSession();
2025    
2026                            UserNotificationEvent[] array = new UserNotificationEventImpl[3];
2027    
2028                            array[0] = getByU_D_PrevAndNext(session, userNotificationEvent,
2029                                            userId, delivered, orderByComparator, true);
2030    
2031                            array[1] = userNotificationEvent;
2032    
2033                            array[2] = getByU_D_PrevAndNext(session, userNotificationEvent,
2034                                            userId, delivered, orderByComparator, false);
2035    
2036                            return array;
2037                    }
2038                    catch (Exception e) {
2039                            throw processException(e);
2040                    }
2041                    finally {
2042                            closeSession(session);
2043                    }
2044            }
2045    
2046            protected UserNotificationEvent getByU_D_PrevAndNext(Session session,
2047                    UserNotificationEvent userNotificationEvent, long userId,
2048                    boolean delivered, OrderByComparator orderByComparator, boolean previous) {
2049                    StringBundler query = null;
2050    
2051                    if (orderByComparator != null) {
2052                            query = new StringBundler(6 +
2053                                            (orderByComparator.getOrderByFields().length * 6));
2054                    }
2055                    else {
2056                            query = new StringBundler(3);
2057                    }
2058    
2059                    query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
2060    
2061                    query.append(_FINDER_COLUMN_U_D_USERID_2);
2062    
2063                    query.append(_FINDER_COLUMN_U_D_DELIVERED_2);
2064    
2065                    if (orderByComparator != null) {
2066                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2067    
2068                            if (orderByConditionFields.length > 0) {
2069                                    query.append(WHERE_AND);
2070                            }
2071    
2072                            for (int i = 0; i < orderByConditionFields.length; i++) {
2073                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2074                                    query.append(orderByConditionFields[i]);
2075    
2076                                    if ((i + 1) < orderByConditionFields.length) {
2077                                            if (orderByComparator.isAscending() ^ previous) {
2078                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2079                                            }
2080                                            else {
2081                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2082                                            }
2083                                    }
2084                                    else {
2085                                            if (orderByComparator.isAscending() ^ previous) {
2086                                                    query.append(WHERE_GREATER_THAN);
2087                                            }
2088                                            else {
2089                                                    query.append(WHERE_LESSER_THAN);
2090                                            }
2091                                    }
2092                            }
2093    
2094                            query.append(ORDER_BY_CLAUSE);
2095    
2096                            String[] orderByFields = orderByComparator.getOrderByFields();
2097    
2098                            for (int i = 0; i < orderByFields.length; i++) {
2099                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2100                                    query.append(orderByFields[i]);
2101    
2102                                    if ((i + 1) < orderByFields.length) {
2103                                            if (orderByComparator.isAscending() ^ previous) {
2104                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2105                                            }
2106                                            else {
2107                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2108                                            }
2109                                    }
2110                                    else {
2111                                            if (orderByComparator.isAscending() ^ previous) {
2112                                                    query.append(ORDER_BY_ASC);
2113                                            }
2114                                            else {
2115                                                    query.append(ORDER_BY_DESC);
2116                                            }
2117                                    }
2118                            }
2119                    }
2120                    else {
2121                            query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
2122                    }
2123    
2124                    String sql = query.toString();
2125    
2126                    Query q = session.createQuery(sql);
2127    
2128                    q.setFirstResult(0);
2129                    q.setMaxResults(2);
2130    
2131                    QueryPos qPos = QueryPos.getInstance(q);
2132    
2133                    qPos.add(userId);
2134    
2135                    qPos.add(delivered);
2136    
2137                    if (orderByComparator != null) {
2138                            Object[] values = orderByComparator.getOrderByConditionValues(userNotificationEvent);
2139    
2140                            for (Object value : values) {
2141                                    qPos.add(value);
2142                            }
2143                    }
2144    
2145                    List<UserNotificationEvent> list = q.list();
2146    
2147                    if (list.size() == 2) {
2148                            return list.get(1);
2149                    }
2150                    else {
2151                            return null;
2152                    }
2153            }
2154    
2155            /**
2156             * Removes all the user notification events where userId = &#63; and delivered = &#63; from the database.
2157             *
2158             * @param userId the user ID
2159             * @param delivered the delivered
2160             * @throws SystemException if a system exception occurred
2161             */
2162            @Override
2163            public void removeByU_D(long userId, boolean delivered)
2164                    throws SystemException {
2165                    for (UserNotificationEvent userNotificationEvent : findByU_D(userId,
2166                                    delivered, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2167                            remove(userNotificationEvent);
2168                    }
2169            }
2170    
2171            /**
2172             * Returns the number of user notification events where userId = &#63; and delivered = &#63;.
2173             *
2174             * @param userId the user ID
2175             * @param delivered the delivered
2176             * @return the number of matching user notification events
2177             * @throws SystemException if a system exception occurred
2178             */
2179            @Override
2180            public int countByU_D(long userId, boolean delivered)
2181                    throws SystemException {
2182                    FinderPath finderPath = FINDER_PATH_COUNT_BY_U_D;
2183    
2184                    Object[] finderArgs = new Object[] { userId, delivered };
2185    
2186                    Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2187                                    this);
2188    
2189                    if (count == null) {
2190                            StringBundler query = new StringBundler(3);
2191    
2192                            query.append(_SQL_COUNT_USERNOTIFICATIONEVENT_WHERE);
2193    
2194                            query.append(_FINDER_COLUMN_U_D_USERID_2);
2195    
2196                            query.append(_FINDER_COLUMN_U_D_DELIVERED_2);
2197    
2198                            String sql = query.toString();
2199    
2200                            Session session = null;
2201    
2202                            try {
2203                                    session = openSession();
2204    
2205                                    Query q = session.createQuery(sql);
2206    
2207                                    QueryPos qPos = QueryPos.getInstance(q);
2208    
2209                                    qPos.add(userId);
2210    
2211                                    qPos.add(delivered);
2212    
2213                                    count = (Long)q.uniqueResult();
2214    
2215                                    FinderCacheUtil.putResult(finderPath, finderArgs, count);
2216                            }
2217                            catch (Exception e) {
2218                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
2219    
2220                                    throw processException(e);
2221                            }
2222                            finally {
2223                                    closeSession(session);
2224                            }
2225                    }
2226    
2227                    return count.intValue();
2228            }
2229    
2230            private static final String _FINDER_COLUMN_U_D_USERID_2 = "userNotificationEvent.userId = ? AND ";
2231            private static final String _FINDER_COLUMN_U_D_DELIVERED_2 = "userNotificationEvent.delivered = ?";
2232            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_U_A = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2233                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
2234                            UserNotificationEventImpl.class,
2235                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByU_A",
2236                            new String[] {
2237                                    Long.class.getName(), Boolean.class.getName(),
2238                                    
2239                            Integer.class.getName(), Integer.class.getName(),
2240                                    OrderByComparator.class.getName()
2241                            });
2242            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_A = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2243                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED,
2244                            UserNotificationEventImpl.class,
2245                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByU_A",
2246                            new String[] { Long.class.getName(), Boolean.class.getName() },
2247                            UserNotificationEventModelImpl.USERID_COLUMN_BITMASK |
2248                            UserNotificationEventModelImpl.ARCHIVED_COLUMN_BITMASK |
2249                            UserNotificationEventModelImpl.TIMESTAMP_COLUMN_BITMASK);
2250            public static final FinderPath FINDER_PATH_COUNT_BY_U_A = new FinderPath(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2251                            UserNotificationEventModelImpl.FINDER_CACHE_ENABLED, Long.class,
2252                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByU_A",
2253                            new String[] { Long.class.getName(), Boolean.class.getName() });
2254    
2255            /**
2256             * Returns all the user notification events where userId = &#63; and archived = &#63;.
2257             *
2258             * @param userId the user ID
2259             * @param archived the archived
2260             * @return the matching user notification events
2261             * @throws SystemException if a system exception occurred
2262             */
2263            @Override
2264            public List<UserNotificationEvent> findByU_A(long userId, boolean archived)
2265                    throws SystemException {
2266                    return findByU_A(userId, archived, QueryUtil.ALL_POS,
2267                            QueryUtil.ALL_POS, null);
2268            }
2269    
2270            /**
2271             * Returns a range of all the user notification events where userId = &#63; and archived = &#63;.
2272             *
2273             * <p>
2274             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
2275             * </p>
2276             *
2277             * @param userId the user ID
2278             * @param archived the archived
2279             * @param start the lower bound of the range of user notification events
2280             * @param end the upper bound of the range of user notification events (not inclusive)
2281             * @return the range of matching user notification events
2282             * @throws SystemException if a system exception occurred
2283             */
2284            @Override
2285            public List<UserNotificationEvent> findByU_A(long userId, boolean archived,
2286                    int start, int end) throws SystemException {
2287                    return findByU_A(userId, archived, start, end, null);
2288            }
2289    
2290            /**
2291             * Returns an ordered range of all the user notification events where userId = &#63; and archived = &#63;.
2292             *
2293             * <p>
2294             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
2295             * </p>
2296             *
2297             * @param userId the user ID
2298             * @param archived the archived
2299             * @param start the lower bound of the range of user notification events
2300             * @param end the upper bound of the range of user notification events (not inclusive)
2301             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2302             * @return the ordered range of matching user notification events
2303             * @throws SystemException if a system exception occurred
2304             */
2305            @Override
2306            public List<UserNotificationEvent> findByU_A(long userId, boolean archived,
2307                    int start, int end, OrderByComparator orderByComparator)
2308                    throws SystemException {
2309                    boolean pagination = true;
2310                    FinderPath finderPath = null;
2311                    Object[] finderArgs = null;
2312    
2313                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2314                                    (orderByComparator == null)) {
2315                            pagination = false;
2316                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_A;
2317                            finderArgs = new Object[] { userId, archived };
2318                    }
2319                    else {
2320                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_U_A;
2321                            finderArgs = new Object[] {
2322                                            userId, archived,
2323                                            
2324                                            start, end, orderByComparator
2325                                    };
2326                    }
2327    
2328                    List<UserNotificationEvent> list = (List<UserNotificationEvent>)FinderCacheUtil.getResult(finderPath,
2329                                    finderArgs, this);
2330    
2331                    if ((list != null) && !list.isEmpty()) {
2332                            for (UserNotificationEvent userNotificationEvent : list) {
2333                                    if ((userId != userNotificationEvent.getUserId()) ||
2334                                                    (archived != userNotificationEvent.getArchived())) {
2335                                            list = null;
2336    
2337                                            break;
2338                                    }
2339                            }
2340                    }
2341    
2342                    if (list == null) {
2343                            StringBundler query = null;
2344    
2345                            if (orderByComparator != null) {
2346                                    query = new StringBundler(4 +
2347                                                    (orderByComparator.getOrderByFields().length * 3));
2348                            }
2349                            else {
2350                                    query = new StringBundler(4);
2351                            }
2352    
2353                            query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
2354    
2355                            query.append(_FINDER_COLUMN_U_A_USERID_2);
2356    
2357                            query.append(_FINDER_COLUMN_U_A_ARCHIVED_2);
2358    
2359                            if (orderByComparator != null) {
2360                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2361                                            orderByComparator);
2362                            }
2363                            else
2364                             if (pagination) {
2365                                    query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
2366                            }
2367    
2368                            String sql = query.toString();
2369    
2370                            Session session = null;
2371    
2372                            try {
2373                                    session = openSession();
2374    
2375                                    Query q = session.createQuery(sql);
2376    
2377                                    QueryPos qPos = QueryPos.getInstance(q);
2378    
2379                                    qPos.add(userId);
2380    
2381                                    qPos.add(archived);
2382    
2383                                    if (!pagination) {
2384                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
2385                                                            getDialect(), start, end, false);
2386    
2387                                            Collections.sort(list);
2388    
2389                                            list = new UnmodifiableList<UserNotificationEvent>(list);
2390                                    }
2391                                    else {
2392                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
2393                                                            getDialect(), start, end);
2394                                    }
2395    
2396                                    cacheResult(list);
2397    
2398                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
2399                            }
2400                            catch (Exception e) {
2401                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
2402    
2403                                    throw processException(e);
2404                            }
2405                            finally {
2406                                    closeSession(session);
2407                            }
2408                    }
2409    
2410                    return list;
2411            }
2412    
2413            /**
2414             * Returns the first user notification event in the ordered set where userId = &#63; and archived = &#63;.
2415             *
2416             * @param userId the user ID
2417             * @param archived the archived
2418             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2419             * @return the first matching user notification event
2420             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
2421             * @throws SystemException if a system exception occurred
2422             */
2423            @Override
2424            public UserNotificationEvent findByU_A_First(long userId, boolean archived,
2425                    OrderByComparator orderByComparator)
2426                    throws NoSuchUserNotificationEventException, SystemException {
2427                    UserNotificationEvent userNotificationEvent = fetchByU_A_First(userId,
2428                                    archived, orderByComparator);
2429    
2430                    if (userNotificationEvent != null) {
2431                            return userNotificationEvent;
2432                    }
2433    
2434                    StringBundler msg = new StringBundler(6);
2435    
2436                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2437    
2438                    msg.append("userId=");
2439                    msg.append(userId);
2440    
2441                    msg.append(", archived=");
2442                    msg.append(archived);
2443    
2444                    msg.append(StringPool.CLOSE_CURLY_BRACE);
2445    
2446                    throw new NoSuchUserNotificationEventException(msg.toString());
2447            }
2448    
2449            /**
2450             * Returns the first user notification event in the ordered set where userId = &#63; and archived = &#63;.
2451             *
2452             * @param userId the user ID
2453             * @param archived the archived
2454             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2455             * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
2456             * @throws SystemException if a system exception occurred
2457             */
2458            @Override
2459            public UserNotificationEvent fetchByU_A_First(long userId,
2460                    boolean archived, OrderByComparator orderByComparator)
2461                    throws SystemException {
2462                    List<UserNotificationEvent> list = findByU_A(userId, archived, 0, 1,
2463                                    orderByComparator);
2464    
2465                    if (!list.isEmpty()) {
2466                            return list.get(0);
2467                    }
2468    
2469                    return null;
2470            }
2471    
2472            /**
2473             * Returns the last user notification event in the ordered set where userId = &#63; and archived = &#63;.
2474             *
2475             * @param userId the user ID
2476             * @param archived the archived
2477             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2478             * @return the last matching user notification event
2479             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a matching user notification event could not be found
2480             * @throws SystemException if a system exception occurred
2481             */
2482            @Override
2483            public UserNotificationEvent findByU_A_Last(long userId, boolean archived,
2484                    OrderByComparator orderByComparator)
2485                    throws NoSuchUserNotificationEventException, SystemException {
2486                    UserNotificationEvent userNotificationEvent = fetchByU_A_Last(userId,
2487                                    archived, orderByComparator);
2488    
2489                    if (userNotificationEvent != null) {
2490                            return userNotificationEvent;
2491                    }
2492    
2493                    StringBundler msg = new StringBundler(6);
2494    
2495                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2496    
2497                    msg.append("userId=");
2498                    msg.append(userId);
2499    
2500                    msg.append(", archived=");
2501                    msg.append(archived);
2502    
2503                    msg.append(StringPool.CLOSE_CURLY_BRACE);
2504    
2505                    throw new NoSuchUserNotificationEventException(msg.toString());
2506            }
2507    
2508            /**
2509             * Returns the last user notification event in the ordered set where userId = &#63; and archived = &#63;.
2510             *
2511             * @param userId the user ID
2512             * @param archived the archived
2513             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2514             * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
2515             * @throws SystemException if a system exception occurred
2516             */
2517            @Override
2518            public UserNotificationEvent fetchByU_A_Last(long userId, boolean archived,
2519                    OrderByComparator orderByComparator) throws SystemException {
2520                    int count = countByU_A(userId, archived);
2521    
2522                    if (count == 0) {
2523                            return null;
2524                    }
2525    
2526                    List<UserNotificationEvent> list = findByU_A(userId, archived,
2527                                    count - 1, count, orderByComparator);
2528    
2529                    if (!list.isEmpty()) {
2530                            return list.get(0);
2531                    }
2532    
2533                    return null;
2534            }
2535    
2536            /**
2537             * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and archived = &#63;.
2538             *
2539             * @param userNotificationEventId the primary key of the current user notification event
2540             * @param userId the user ID
2541             * @param archived the archived
2542             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2543             * @return the previous, current, and next user notification event
2544             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2545             * @throws SystemException if a system exception occurred
2546             */
2547            @Override
2548            public UserNotificationEvent[] findByU_A_PrevAndNext(
2549                    long userNotificationEventId, long userId, boolean archived,
2550                    OrderByComparator orderByComparator)
2551                    throws NoSuchUserNotificationEventException, SystemException {
2552                    UserNotificationEvent userNotificationEvent = findByPrimaryKey(userNotificationEventId);
2553    
2554                    Session session = null;
2555    
2556                    try {
2557                            session = openSession();
2558    
2559                            UserNotificationEvent[] array = new UserNotificationEventImpl[3];
2560    
2561                            array[0] = getByU_A_PrevAndNext(session, userNotificationEvent,
2562                                            userId, archived, orderByComparator, true);
2563    
2564                            array[1] = userNotificationEvent;
2565    
2566                            array[2] = getByU_A_PrevAndNext(session, userNotificationEvent,
2567                                            userId, archived, orderByComparator, false);
2568    
2569                            return array;
2570                    }
2571                    catch (Exception e) {
2572                            throw processException(e);
2573                    }
2574                    finally {
2575                            closeSession(session);
2576                    }
2577            }
2578    
2579            protected UserNotificationEvent getByU_A_PrevAndNext(Session session,
2580                    UserNotificationEvent userNotificationEvent, long userId,
2581                    boolean archived, OrderByComparator orderByComparator, boolean previous) {
2582                    StringBundler query = null;
2583    
2584                    if (orderByComparator != null) {
2585                            query = new StringBundler(6 +
2586                                            (orderByComparator.getOrderByFields().length * 6));
2587                    }
2588                    else {
2589                            query = new StringBundler(3);
2590                    }
2591    
2592                    query.append(_SQL_SELECT_USERNOTIFICATIONEVENT_WHERE);
2593    
2594                    query.append(_FINDER_COLUMN_U_A_USERID_2);
2595    
2596                    query.append(_FINDER_COLUMN_U_A_ARCHIVED_2);
2597    
2598                    if (orderByComparator != null) {
2599                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2600    
2601                            if (orderByConditionFields.length > 0) {
2602                                    query.append(WHERE_AND);
2603                            }
2604    
2605                            for (int i = 0; i < orderByConditionFields.length; i++) {
2606                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2607                                    query.append(orderByConditionFields[i]);
2608    
2609                                    if ((i + 1) < orderByConditionFields.length) {
2610                                            if (orderByComparator.isAscending() ^ previous) {
2611                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2612                                            }
2613                                            else {
2614                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2615                                            }
2616                                    }
2617                                    else {
2618                                            if (orderByComparator.isAscending() ^ previous) {
2619                                                    query.append(WHERE_GREATER_THAN);
2620                                            }
2621                                            else {
2622                                                    query.append(WHERE_LESSER_THAN);
2623                                            }
2624                                    }
2625                            }
2626    
2627                            query.append(ORDER_BY_CLAUSE);
2628    
2629                            String[] orderByFields = orderByComparator.getOrderByFields();
2630    
2631                            for (int i = 0; i < orderByFields.length; i++) {
2632                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2633                                    query.append(orderByFields[i]);
2634    
2635                                    if ((i + 1) < orderByFields.length) {
2636                                            if (orderByComparator.isAscending() ^ previous) {
2637                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2638                                            }
2639                                            else {
2640                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2641                                            }
2642                                    }
2643                                    else {
2644                                            if (orderByComparator.isAscending() ^ previous) {
2645                                                    query.append(ORDER_BY_ASC);
2646                                            }
2647                                            else {
2648                                                    query.append(ORDER_BY_DESC);
2649                                            }
2650                                    }
2651                            }
2652                    }
2653                    else {
2654                            query.append(UserNotificationEventModelImpl.ORDER_BY_JPQL);
2655                    }
2656    
2657                    String sql = query.toString();
2658    
2659                    Query q = session.createQuery(sql);
2660    
2661                    q.setFirstResult(0);
2662                    q.setMaxResults(2);
2663    
2664                    QueryPos qPos = QueryPos.getInstance(q);
2665    
2666                    qPos.add(userId);
2667    
2668                    qPos.add(archived);
2669    
2670                    if (orderByComparator != null) {
2671                            Object[] values = orderByComparator.getOrderByConditionValues(userNotificationEvent);
2672    
2673                            for (Object value : values) {
2674                                    qPos.add(value);
2675                            }
2676                    }
2677    
2678                    List<UserNotificationEvent> list = q.list();
2679    
2680                    if (list.size() == 2) {
2681                            return list.get(1);
2682                    }
2683                    else {
2684                            return null;
2685                    }
2686            }
2687    
2688            /**
2689             * Removes all the user notification events where userId = &#63; and archived = &#63; from the database.
2690             *
2691             * @param userId the user ID
2692             * @param archived the archived
2693             * @throws SystemException if a system exception occurred
2694             */
2695            @Override
2696            public void removeByU_A(long userId, boolean archived)
2697                    throws SystemException {
2698                    for (UserNotificationEvent userNotificationEvent : findByU_A(userId,
2699                                    archived, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2700                            remove(userNotificationEvent);
2701                    }
2702            }
2703    
2704            /**
2705             * Returns the number of user notification events where userId = &#63; and archived = &#63;.
2706             *
2707             * @param userId the user ID
2708             * @param archived the archived
2709             * @return the number of matching user notification events
2710             * @throws SystemException if a system exception occurred
2711             */
2712            @Override
2713            public int countByU_A(long userId, boolean archived)
2714                    throws SystemException {
2715                    FinderPath finderPath = FINDER_PATH_COUNT_BY_U_A;
2716    
2717                    Object[] finderArgs = new Object[] { userId, archived };
2718    
2719                    Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2720                                    this);
2721    
2722                    if (count == null) {
2723                            StringBundler query = new StringBundler(3);
2724    
2725                            query.append(_SQL_COUNT_USERNOTIFICATIONEVENT_WHERE);
2726    
2727                            query.append(_FINDER_COLUMN_U_A_USERID_2);
2728    
2729                            query.append(_FINDER_COLUMN_U_A_ARCHIVED_2);
2730    
2731                            String sql = query.toString();
2732    
2733                            Session session = null;
2734    
2735                            try {
2736                                    session = openSession();
2737    
2738                                    Query q = session.createQuery(sql);
2739    
2740                                    QueryPos qPos = QueryPos.getInstance(q);
2741    
2742                                    qPos.add(userId);
2743    
2744                                    qPos.add(archived);
2745    
2746                                    count = (Long)q.uniqueResult();
2747    
2748                                    FinderCacheUtil.putResult(finderPath, finderArgs, count);
2749                            }
2750                            catch (Exception e) {
2751                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
2752    
2753                                    throw processException(e);
2754                            }
2755                            finally {
2756                                    closeSession(session);
2757                            }
2758                    }
2759    
2760                    return count.intValue();
2761            }
2762    
2763            private static final String _FINDER_COLUMN_U_A_USERID_2 = "userNotificationEvent.userId = ? AND ";
2764            private static final String _FINDER_COLUMN_U_A_ARCHIVED_2 = "userNotificationEvent.archived = ?";
2765    
2766            public UserNotificationEventPersistenceImpl() {
2767                    setModelClass(UserNotificationEvent.class);
2768            }
2769    
2770            /**
2771             * Caches the user notification event in the entity cache if it is enabled.
2772             *
2773             * @param userNotificationEvent the user notification event
2774             */
2775            @Override
2776            public void cacheResult(UserNotificationEvent userNotificationEvent) {
2777                    EntityCacheUtil.putResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2778                            UserNotificationEventImpl.class,
2779                            userNotificationEvent.getPrimaryKey(), userNotificationEvent);
2780    
2781                    userNotificationEvent.resetOriginalValues();
2782            }
2783    
2784            /**
2785             * Caches the user notification events in the entity cache if it is enabled.
2786             *
2787             * @param userNotificationEvents the user notification events
2788             */
2789            @Override
2790            public void cacheResult(List<UserNotificationEvent> userNotificationEvents) {
2791                    for (UserNotificationEvent userNotificationEvent : userNotificationEvents) {
2792                            if (EntityCacheUtil.getResult(
2793                                                    UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2794                                                    UserNotificationEventImpl.class,
2795                                                    userNotificationEvent.getPrimaryKey()) == null) {
2796                                    cacheResult(userNotificationEvent);
2797                            }
2798                            else {
2799                                    userNotificationEvent.resetOriginalValues();
2800                            }
2801                    }
2802            }
2803    
2804            /**
2805             * Clears the cache for all user notification events.
2806             *
2807             * <p>
2808             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
2809             * </p>
2810             */
2811            @Override
2812            public void clearCache() {
2813                    if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
2814                            CacheRegistryUtil.clear(UserNotificationEventImpl.class.getName());
2815                    }
2816    
2817                    EntityCacheUtil.clearCache(UserNotificationEventImpl.class.getName());
2818    
2819                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
2820                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2821                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2822            }
2823    
2824            /**
2825             * Clears the cache for the user notification event.
2826             *
2827             * <p>
2828             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
2829             * </p>
2830             */
2831            @Override
2832            public void clearCache(UserNotificationEvent userNotificationEvent) {
2833                    EntityCacheUtil.removeResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2834                            UserNotificationEventImpl.class,
2835                            userNotificationEvent.getPrimaryKey());
2836    
2837                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2838                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2839            }
2840    
2841            @Override
2842            public void clearCache(List<UserNotificationEvent> userNotificationEvents) {
2843                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2844                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2845    
2846                    for (UserNotificationEvent userNotificationEvent : userNotificationEvents) {
2847                            EntityCacheUtil.removeResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
2848                                    UserNotificationEventImpl.class,
2849                                    userNotificationEvent.getPrimaryKey());
2850                    }
2851            }
2852    
2853            /**
2854             * Creates a new user notification event with the primary key. Does not add the user notification event to the database.
2855             *
2856             * @param userNotificationEventId the primary key for the new user notification event
2857             * @return the new user notification event
2858             */
2859            @Override
2860            public UserNotificationEvent create(long userNotificationEventId) {
2861                    UserNotificationEvent userNotificationEvent = new UserNotificationEventImpl();
2862    
2863                    userNotificationEvent.setNew(true);
2864                    userNotificationEvent.setPrimaryKey(userNotificationEventId);
2865    
2866                    String uuid = PortalUUIDUtil.generate();
2867    
2868                    userNotificationEvent.setUuid(uuid);
2869    
2870                    return userNotificationEvent;
2871            }
2872    
2873            /**
2874             * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners.
2875             *
2876             * @param userNotificationEventId the primary key of the user notification event
2877             * @return the user notification event that was removed
2878             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2879             * @throws SystemException if a system exception occurred
2880             */
2881            @Override
2882            public UserNotificationEvent remove(long userNotificationEventId)
2883                    throws NoSuchUserNotificationEventException, SystemException {
2884                    return remove((Serializable)userNotificationEventId);
2885            }
2886    
2887            /**
2888             * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners.
2889             *
2890             * @param primaryKey the primary key of the user notification event
2891             * @return the user notification event that was removed
2892             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2893             * @throws SystemException if a system exception occurred
2894             */
2895            @Override
2896            public UserNotificationEvent remove(Serializable primaryKey)
2897                    throws NoSuchUserNotificationEventException, SystemException {
2898                    Session session = null;
2899    
2900                    try {
2901                            session = openSession();
2902    
2903                            UserNotificationEvent userNotificationEvent = (UserNotificationEvent)session.get(UserNotificationEventImpl.class,
2904                                            primaryKey);
2905    
2906                            if (userNotificationEvent == null) {
2907                                    if (_log.isWarnEnabled()) {
2908                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2909                                    }
2910    
2911                                    throw new NoSuchUserNotificationEventException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2912                                            primaryKey);
2913                            }
2914    
2915                            return remove(userNotificationEvent);
2916                    }
2917                    catch (NoSuchUserNotificationEventException nsee) {
2918                            throw nsee;
2919                    }
2920                    catch (Exception e) {
2921                            throw processException(e);
2922                    }
2923                    finally {
2924                            closeSession(session);
2925                    }
2926            }
2927    
2928            @Override
2929            protected UserNotificationEvent removeImpl(
2930                    UserNotificationEvent userNotificationEvent) throws SystemException {
2931                    userNotificationEvent = toUnwrappedModel(userNotificationEvent);
2932    
2933                    Session session = null;
2934    
2935                    try {
2936                            session = openSession();
2937    
2938                            if (!session.contains(userNotificationEvent)) {
2939                                    userNotificationEvent = (UserNotificationEvent)session.get(UserNotificationEventImpl.class,
2940                                                    userNotificationEvent.getPrimaryKeyObj());
2941                            }
2942    
2943                            if (userNotificationEvent != null) {
2944                                    session.delete(userNotificationEvent);
2945                            }
2946                    }
2947                    catch (Exception e) {
2948                            throw processException(e);
2949                    }
2950                    finally {
2951                            closeSession(session);
2952                    }
2953    
2954                    if (userNotificationEvent != null) {
2955                            clearCache(userNotificationEvent);
2956                    }
2957    
2958                    return userNotificationEvent;
2959            }
2960    
2961            @Override
2962            public UserNotificationEvent updateImpl(
2963                    com.liferay.portal.model.UserNotificationEvent userNotificationEvent)
2964                    throws SystemException {
2965                    userNotificationEvent = toUnwrappedModel(userNotificationEvent);
2966    
2967                    boolean isNew = userNotificationEvent.isNew();
2968    
2969                    UserNotificationEventModelImpl userNotificationEventModelImpl = (UserNotificationEventModelImpl)userNotificationEvent;
2970    
2971                    if (Validator.isNull(userNotificationEvent.getUuid())) {
2972                            String uuid = PortalUUIDUtil.generate();
2973    
2974                            userNotificationEvent.setUuid(uuid);
2975                    }
2976    
2977                    Session session = null;
2978    
2979                    try {
2980                            session = openSession();
2981    
2982                            if (userNotificationEvent.isNew()) {
2983                                    session.save(userNotificationEvent);
2984    
2985                                    userNotificationEvent.setNew(false);
2986                            }
2987                            else {
2988                                    session.merge(userNotificationEvent);
2989                            }
2990                    }
2991                    catch (Exception e) {
2992                            throw processException(e);
2993                    }
2994                    finally {
2995                            closeSession(session);
2996                    }
2997    
2998                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2999    
3000                    if (isNew || !UserNotificationEventModelImpl.COLUMN_BITMASK_ENABLED) {
3001                            FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
3002                    }
3003    
3004                    else {
3005                            if ((userNotificationEventModelImpl.getColumnBitmask() &
3006                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
3007                                    Object[] args = new Object[] {
3008                                                    userNotificationEventModelImpl.getOriginalUuid()
3009                                            };
3010    
3011                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
3012                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
3013                                            args);
3014    
3015                                    args = new Object[] { userNotificationEventModelImpl.getUuid() };
3016    
3017                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
3018                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
3019                                            args);
3020                            }
3021    
3022                            if ((userNotificationEventModelImpl.getColumnBitmask() &
3023                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
3024                                    Object[] args = new Object[] {
3025                                                    userNotificationEventModelImpl.getOriginalUuid(),
3026                                                    userNotificationEventModelImpl.getOriginalCompanyId()
3027                                            };
3028    
3029                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
3030                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
3031                                            args);
3032    
3033                                    args = new Object[] {
3034                                                    userNotificationEventModelImpl.getUuid(),
3035                                                    userNotificationEventModelImpl.getCompanyId()
3036                                            };
3037    
3038                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
3039                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
3040                                            args);
3041                            }
3042    
3043                            if ((userNotificationEventModelImpl.getColumnBitmask() &
3044                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID.getColumnBitmask()) != 0) {
3045                                    Object[] args = new Object[] {
3046                                                    userNotificationEventModelImpl.getOriginalUserId()
3047                                            };
3048    
3049                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
3050                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID,
3051                                            args);
3052    
3053                                    args = new Object[] { userNotificationEventModelImpl.getUserId() };
3054    
3055                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
3056                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID,
3057                                            args);
3058                            }
3059    
3060                            if ((userNotificationEventModelImpl.getColumnBitmask() &
3061                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_D.getColumnBitmask()) != 0) {
3062                                    Object[] args = new Object[] {
3063                                                    userNotificationEventModelImpl.getOriginalUserId(),
3064                                                    userNotificationEventModelImpl.getOriginalDelivered()
3065                                            };
3066    
3067                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U_D, args);
3068                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_D,
3069                                            args);
3070    
3071                                    args = new Object[] {
3072                                                    userNotificationEventModelImpl.getUserId(),
3073                                                    userNotificationEventModelImpl.getDelivered()
3074                                            };
3075    
3076                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U_D, args);
3077                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_D,
3078                                            args);
3079                            }
3080    
3081                            if ((userNotificationEventModelImpl.getColumnBitmask() &
3082                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_A.getColumnBitmask()) != 0) {
3083                                    Object[] args = new Object[] {
3084                                                    userNotificationEventModelImpl.getOriginalUserId(),
3085                                                    userNotificationEventModelImpl.getOriginalArchived()
3086                                            };
3087    
3088                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U_A, args);
3089                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_A,
3090                                            args);
3091    
3092                                    args = new Object[] {
3093                                                    userNotificationEventModelImpl.getUserId(),
3094                                                    userNotificationEventModelImpl.getArchived()
3095                                            };
3096    
3097                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U_A, args);
3098                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U_A,
3099                                            args);
3100                            }
3101                    }
3102    
3103                    EntityCacheUtil.putResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
3104                            UserNotificationEventImpl.class,
3105                            userNotificationEvent.getPrimaryKey(), userNotificationEvent);
3106    
3107                    return userNotificationEvent;
3108            }
3109    
3110            protected UserNotificationEvent toUnwrappedModel(
3111                    UserNotificationEvent userNotificationEvent) {
3112                    if (userNotificationEvent instanceof UserNotificationEventImpl) {
3113                            return userNotificationEvent;
3114                    }
3115    
3116                    UserNotificationEventImpl userNotificationEventImpl = new UserNotificationEventImpl();
3117    
3118                    userNotificationEventImpl.setNew(userNotificationEvent.isNew());
3119                    userNotificationEventImpl.setPrimaryKey(userNotificationEvent.getPrimaryKey());
3120    
3121                    userNotificationEventImpl.setUuid(userNotificationEvent.getUuid());
3122                    userNotificationEventImpl.setUserNotificationEventId(userNotificationEvent.getUserNotificationEventId());
3123                    userNotificationEventImpl.setCompanyId(userNotificationEvent.getCompanyId());
3124                    userNotificationEventImpl.setUserId(userNotificationEvent.getUserId());
3125                    userNotificationEventImpl.setType(userNotificationEvent.getType());
3126                    userNotificationEventImpl.setTimestamp(userNotificationEvent.getTimestamp());
3127                    userNotificationEventImpl.setDeliverBy(userNotificationEvent.getDeliverBy());
3128                    userNotificationEventImpl.setDelivered(userNotificationEvent.isDelivered());
3129                    userNotificationEventImpl.setPayload(userNotificationEvent.getPayload());
3130                    userNotificationEventImpl.setArchived(userNotificationEvent.isArchived());
3131    
3132                    return userNotificationEventImpl;
3133            }
3134    
3135            /**
3136             * Returns the user notification event with the primary key or throws a {@link com.liferay.portal.NoSuchModelException} if it could not be found.
3137             *
3138             * @param primaryKey the primary key of the user notification event
3139             * @return the user notification event
3140             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
3141             * @throws SystemException if a system exception occurred
3142             */
3143            @Override
3144            public UserNotificationEvent findByPrimaryKey(Serializable primaryKey)
3145                    throws NoSuchUserNotificationEventException, SystemException {
3146                    UserNotificationEvent userNotificationEvent = fetchByPrimaryKey(primaryKey);
3147    
3148                    if (userNotificationEvent == null) {
3149                            if (_log.isWarnEnabled()) {
3150                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
3151                            }
3152    
3153                            throw new NoSuchUserNotificationEventException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
3154                                    primaryKey);
3155                    }
3156    
3157                    return userNotificationEvent;
3158            }
3159    
3160            /**
3161             * Returns the user notification event with the primary key or throws a {@link com.liferay.portal.NoSuchUserNotificationEventException} if it could not be found.
3162             *
3163             * @param userNotificationEventId the primary key of the user notification event
3164             * @return the user notification event
3165             * @throws com.liferay.portal.NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
3166             * @throws SystemException if a system exception occurred
3167             */
3168            @Override
3169            public UserNotificationEvent findByPrimaryKey(long userNotificationEventId)
3170                    throws NoSuchUserNotificationEventException, SystemException {
3171                    return findByPrimaryKey((Serializable)userNotificationEventId);
3172            }
3173    
3174            /**
3175             * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found.
3176             *
3177             * @param primaryKey the primary key of the user notification event
3178             * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found
3179             * @throws SystemException if a system exception occurred
3180             */
3181            @Override
3182            public UserNotificationEvent fetchByPrimaryKey(Serializable primaryKey)
3183                    throws SystemException {
3184                    UserNotificationEvent userNotificationEvent = (UserNotificationEvent)EntityCacheUtil.getResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
3185                                    UserNotificationEventImpl.class, primaryKey);
3186    
3187                    if (userNotificationEvent == _nullUserNotificationEvent) {
3188                            return null;
3189                    }
3190    
3191                    if (userNotificationEvent == null) {
3192                            Session session = null;
3193    
3194                            try {
3195                                    session = openSession();
3196    
3197                                    userNotificationEvent = (UserNotificationEvent)session.get(UserNotificationEventImpl.class,
3198                                                    primaryKey);
3199    
3200                                    if (userNotificationEvent != null) {
3201                                            cacheResult(userNotificationEvent);
3202                                    }
3203                                    else {
3204                                            EntityCacheUtil.putResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
3205                                                    UserNotificationEventImpl.class, primaryKey,
3206                                                    _nullUserNotificationEvent);
3207                                    }
3208                            }
3209                            catch (Exception e) {
3210                                    EntityCacheUtil.removeResult(UserNotificationEventModelImpl.ENTITY_CACHE_ENABLED,
3211                                            UserNotificationEventImpl.class, primaryKey);
3212    
3213                                    throw processException(e);
3214                            }
3215                            finally {
3216                                    closeSession(session);
3217                            }
3218                    }
3219    
3220                    return userNotificationEvent;
3221            }
3222    
3223            /**
3224             * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found.
3225             *
3226             * @param userNotificationEventId the primary key of the user notification event
3227             * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found
3228             * @throws SystemException if a system exception occurred
3229             */
3230            @Override
3231            public UserNotificationEvent fetchByPrimaryKey(long userNotificationEventId)
3232                    throws SystemException {
3233                    return fetchByPrimaryKey((Serializable)userNotificationEventId);
3234            }
3235    
3236            /**
3237             * Returns all the user notification events.
3238             *
3239             * @return the user notification events
3240             * @throws SystemException if a system exception occurred
3241             */
3242            @Override
3243            public List<UserNotificationEvent> findAll() throws SystemException {
3244                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3245            }
3246    
3247            /**
3248             * Returns a range of all the user notification events.
3249             *
3250             * <p>
3251             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
3252             * </p>
3253             *
3254             * @param start the lower bound of the range of user notification events
3255             * @param end the upper bound of the range of user notification events (not inclusive)
3256             * @return the range of user notification events
3257             * @throws SystemException if a system exception occurred
3258             */
3259            @Override
3260            public List<UserNotificationEvent> findAll(int start, int end)
3261                    throws SystemException {
3262                    return findAll(start, end, null);
3263            }
3264    
3265            /**
3266             * Returns an ordered range of all the user notification events.
3267             *
3268             * <p>
3269             * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserNotificationEventModelImpl}. 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.
3270             * </p>
3271             *
3272             * @param start the lower bound of the range of user notification events
3273             * @param end the upper bound of the range of user notification events (not inclusive)
3274             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3275             * @return the ordered range of user notification events
3276             * @throws SystemException if a system exception occurred
3277             */
3278            @Override
3279            public List<UserNotificationEvent> findAll(int start, int end,
3280                    OrderByComparator orderByComparator) throws SystemException {
3281                    boolean pagination = true;
3282                    FinderPath finderPath = null;
3283                    Object[] finderArgs = null;
3284    
3285                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3286                                    (orderByComparator == null)) {
3287                            pagination = false;
3288                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
3289                            finderArgs = FINDER_ARGS_EMPTY;
3290                    }
3291                    else {
3292                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
3293                            finderArgs = new Object[] { start, end, orderByComparator };
3294                    }
3295    
3296                    List<UserNotificationEvent> list = (List<UserNotificationEvent>)FinderCacheUtil.getResult(finderPath,
3297                                    finderArgs, this);
3298    
3299                    if (list == null) {
3300                            StringBundler query = null;
3301                            String sql = null;
3302    
3303                            if (orderByComparator != null) {
3304                                    query = new StringBundler(2 +
3305                                                    (orderByComparator.getOrderByFields().length * 3));
3306    
3307                                    query.append(_SQL_SELECT_USERNOTIFICATIONEVENT);
3308    
3309                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3310                                            orderByComparator);
3311    
3312                                    sql = query.toString();
3313                            }
3314                            else {
3315                                    sql = _SQL_SELECT_USERNOTIFICATIONEVENT;
3316    
3317                                    if (pagination) {
3318                                            sql = sql.concat(UserNotificationEventModelImpl.ORDER_BY_JPQL);
3319                                    }
3320                            }
3321    
3322                            Session session = null;
3323    
3324                            try {
3325                                    session = openSession();
3326    
3327                                    Query q = session.createQuery(sql);
3328    
3329                                    if (!pagination) {
3330                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
3331                                                            getDialect(), start, end, false);
3332    
3333                                            Collections.sort(list);
3334    
3335                                            list = new UnmodifiableList<UserNotificationEvent>(list);
3336                                    }
3337                                    else {
3338                                            list = (List<UserNotificationEvent>)QueryUtil.list(q,
3339                                                            getDialect(), start, end);
3340                                    }
3341    
3342                                    cacheResult(list);
3343    
3344                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
3345                            }
3346                            catch (Exception e) {
3347                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
3348    
3349                                    throw processException(e);
3350                            }
3351                            finally {
3352                                    closeSession(session);
3353                            }
3354                    }
3355    
3356                    return list;
3357            }
3358    
3359            /**
3360             * Removes all the user notification events from the database.
3361             *
3362             * @throws SystemException if a system exception occurred
3363             */
3364            @Override
3365            public void removeAll() throws SystemException {
3366                    for (UserNotificationEvent userNotificationEvent : findAll()) {
3367                            remove(userNotificationEvent);
3368                    }
3369            }
3370    
3371            /**
3372             * Returns the number of user notification events.
3373             *
3374             * @return the number of user notification events
3375             * @throws SystemException if a system exception occurred
3376             */
3377            @Override
3378            public int countAll() throws SystemException {
3379                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3380                                    FINDER_ARGS_EMPTY, this);
3381    
3382                    if (count == null) {
3383                            Session session = null;
3384    
3385                            try {
3386                                    session = openSession();
3387    
3388                                    Query q = session.createQuery(_SQL_COUNT_USERNOTIFICATIONEVENT);
3389    
3390                                    count = (Long)q.uniqueResult();
3391    
3392                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
3393                                            FINDER_ARGS_EMPTY, count);
3394                            }
3395                            catch (Exception e) {
3396                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
3397                                            FINDER_ARGS_EMPTY);
3398    
3399                                    throw processException(e);
3400                            }
3401                            finally {
3402                                    closeSession(session);
3403                            }
3404                    }
3405    
3406                    return count.intValue();
3407            }
3408    
3409            @Override
3410            protected Set<String> getBadColumnNames() {
3411                    return _badColumnNames;
3412            }
3413    
3414            /**
3415             * Initializes the user notification event persistence.
3416             */
3417            public void afterPropertiesSet() {
3418                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3419                                            com.liferay.portal.util.PropsUtil.get(
3420                                                    "value.object.listener.com.liferay.portal.model.UserNotificationEvent")));
3421    
3422                    if (listenerClassNames.length > 0) {
3423                            try {
3424                                    List<ModelListener<UserNotificationEvent>> listenersList = new ArrayList<ModelListener<UserNotificationEvent>>();
3425    
3426                                    for (String listenerClassName : listenerClassNames) {
3427                                            listenersList.add((ModelListener<UserNotificationEvent>)InstanceFactory.newInstance(
3428                                                            getClassLoader(), listenerClassName));
3429                                    }
3430    
3431                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3432                            }
3433                            catch (Exception e) {
3434                                    _log.error(e);
3435                            }
3436                    }
3437            }
3438    
3439            public void destroy() {
3440                    EntityCacheUtil.removeCache(UserNotificationEventImpl.class.getName());
3441                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
3442                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
3443                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
3444            }
3445    
3446            private static final String _SQL_SELECT_USERNOTIFICATIONEVENT = "SELECT userNotificationEvent FROM UserNotificationEvent userNotificationEvent";
3447            private static final String _SQL_SELECT_USERNOTIFICATIONEVENT_WHERE = "SELECT userNotificationEvent FROM UserNotificationEvent userNotificationEvent WHERE ";
3448            private static final String _SQL_COUNT_USERNOTIFICATIONEVENT = "SELECT COUNT(userNotificationEvent) FROM UserNotificationEvent userNotificationEvent";
3449            private static final String _SQL_COUNT_USERNOTIFICATIONEVENT_WHERE = "SELECT COUNT(userNotificationEvent) FROM UserNotificationEvent userNotificationEvent WHERE ";
3450            private static final String _ORDER_BY_ENTITY_ALIAS = "userNotificationEvent.";
3451            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No UserNotificationEvent exists with the primary key ";
3452            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No UserNotificationEvent exists with the key {";
3453            private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
3454            private static Log _log = LogFactoryUtil.getLog(UserNotificationEventPersistenceImpl.class);
3455            private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
3456                                    "uuid", "type"
3457                            });
3458            private static UserNotificationEvent _nullUserNotificationEvent = new UserNotificationEventImpl() {
3459                            @Override
3460                            public Object clone() {
3461                                    return this;
3462                            }
3463    
3464                            @Override
3465                            public CacheModel<UserNotificationEvent> toCacheModel() {
3466                                    return _nullUserNotificationEventCacheModel;
3467                            }
3468                    };
3469    
3470            private static CacheModel<UserNotificationEvent> _nullUserNotificationEventCacheModel =
3471                    new CacheModel<UserNotificationEvent>() {
3472                            @Override
3473                            public UserNotificationEvent toEntityModel() {
3474                                    return _nullUserNotificationEvent;
3475                            }
3476                    };
3477    }