1
22
23 package com.liferay.portlet.tags.service.persistence;
24
25 import com.liferay.portal.SystemException;
26 import com.liferay.portal.kernel.annotation.BeanReference;
27 import com.liferay.portal.kernel.cache.CacheRegistry;
28 import com.liferay.portal.kernel.dao.jdbc.MappingSqlQuery;
29 import com.liferay.portal.kernel.dao.jdbc.MappingSqlQueryFactoryUtil;
30 import com.liferay.portal.kernel.dao.jdbc.RowMapper;
31 import com.liferay.portal.kernel.dao.jdbc.SqlUpdate;
32 import com.liferay.portal.kernel.dao.jdbc.SqlUpdateFactoryUtil;
33 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
34 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
35 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
36 import com.liferay.portal.kernel.dao.orm.FinderPath;
37 import com.liferay.portal.kernel.dao.orm.Query;
38 import com.liferay.portal.kernel.dao.orm.QueryPos;
39 import com.liferay.portal.kernel.dao.orm.QueryUtil;
40 import com.liferay.portal.kernel.dao.orm.SQLQuery;
41 import com.liferay.portal.kernel.dao.orm.Session;
42 import com.liferay.portal.kernel.dao.orm.Type;
43 import com.liferay.portal.kernel.log.Log;
44 import com.liferay.portal.kernel.log.LogFactoryUtil;
45 import com.liferay.portal.kernel.util.GetterUtil;
46 import com.liferay.portal.kernel.util.OrderByComparator;
47 import com.liferay.portal.kernel.util.StringPool;
48 import com.liferay.portal.kernel.util.StringUtil;
49 import com.liferay.portal.model.ModelListener;
50 import com.liferay.portal.service.persistence.BatchSessionUtil;
51 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
52
53 import com.liferay.portlet.tags.NoSuchEntryException;
54 import com.liferay.portlet.tags.model.TagsEntry;
55 import com.liferay.portlet.tags.model.impl.TagsEntryImpl;
56 import com.liferay.portlet.tags.model.impl.TagsEntryModelImpl;
57
58 import java.sql.Types;
59
60 import java.util.ArrayList;
61 import java.util.Collections;
62 import java.util.List;
63
64
70 public class TagsEntryPersistenceImpl extends BasePersistenceImpl
71 implements TagsEntryPersistence {
72 public static final String FINDER_CLASS_NAME_ENTITY = TagsEntryImpl.class.getName();
73 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
74 ".List";
75 public static final FinderPath FINDER_PATH_FIND_BY_VOCABULARYID = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
76 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
77 "findByVocabularyId", new String[] { Long.class.getName() });
78 public static final FinderPath FINDER_PATH_FIND_BY_OBC_VOCABULARYID = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
79 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
80 "findByVocabularyId",
81 new String[] {
82 Long.class.getName(),
83
84 "java.lang.Integer", "java.lang.Integer",
85 "com.liferay.portal.kernel.util.OrderByComparator"
86 });
87 public static final FinderPath FINDER_PATH_COUNT_BY_VOCABULARYID = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
88 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
89 "countByVocabularyId", new String[] { Long.class.getName() });
90 public static final FinderPath FINDER_PATH_FIND_BY_P_V = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
91 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
92 "findByP_V",
93 new String[] { Long.class.getName(), Long.class.getName() });
94 public static final FinderPath FINDER_PATH_FIND_BY_OBC_P_V = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
95 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
96 "findByP_V",
97 new String[] {
98 Long.class.getName(), Long.class.getName(),
99
100 "java.lang.Integer", "java.lang.Integer",
101 "com.liferay.portal.kernel.util.OrderByComparator"
102 });
103 public static final FinderPath FINDER_PATH_COUNT_BY_P_V = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
104 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
105 "countByP_V",
106 new String[] { Long.class.getName(), Long.class.getName() });
107 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
108 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
109 "findAll", new String[0]);
110 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
111 TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
112 "countAll", new String[0]);
113
114 public void cacheResult(TagsEntry tagsEntry) {
115 EntityCacheUtil.putResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
116 TagsEntryImpl.class, tagsEntry.getPrimaryKey(), tagsEntry);
117 }
118
119 public void cacheResult(List<TagsEntry> tagsEntries) {
120 for (TagsEntry tagsEntry : tagsEntries) {
121 if (EntityCacheUtil.getResult(
122 TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
123 TagsEntryImpl.class, tagsEntry.getPrimaryKey(), this) == null) {
124 cacheResult(tagsEntry);
125 }
126 }
127 }
128
129 public void clearCache() {
130 CacheRegistry.clear(TagsEntryImpl.class.getName());
131 EntityCacheUtil.clearCache(TagsEntryImpl.class.getName());
132 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
133 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
134 }
135
136 public TagsEntry create(long entryId) {
137 TagsEntry tagsEntry = new TagsEntryImpl();
138
139 tagsEntry.setNew(true);
140 tagsEntry.setPrimaryKey(entryId);
141
142 return tagsEntry;
143 }
144
145 public TagsEntry remove(long entryId)
146 throws NoSuchEntryException, SystemException {
147 Session session = null;
148
149 try {
150 session = openSession();
151
152 TagsEntry tagsEntry = (TagsEntry)session.get(TagsEntryImpl.class,
153 new Long(entryId));
154
155 if (tagsEntry == null) {
156 if (_log.isWarnEnabled()) {
157 _log.warn("No TagsEntry exists with the primary key " +
158 entryId);
159 }
160
161 throw new NoSuchEntryException(
162 "No TagsEntry exists with the primary key " + entryId);
163 }
164
165 return remove(tagsEntry);
166 }
167 catch (NoSuchEntryException nsee) {
168 throw nsee;
169 }
170 catch (Exception e) {
171 throw processException(e);
172 }
173 finally {
174 closeSession(session);
175 }
176 }
177
178 public TagsEntry remove(TagsEntry tagsEntry) throws SystemException {
179 for (ModelListener<TagsEntry> listener : listeners) {
180 listener.onBeforeRemove(tagsEntry);
181 }
182
183 tagsEntry = removeImpl(tagsEntry);
184
185 for (ModelListener<TagsEntry> listener : listeners) {
186 listener.onAfterRemove(tagsEntry);
187 }
188
189 return tagsEntry;
190 }
191
192 protected TagsEntry removeImpl(TagsEntry tagsEntry)
193 throws SystemException {
194 try {
195 clearTagsAssets.clear(tagsEntry.getPrimaryKey());
196 }
197 catch (Exception e) {
198 throw processException(e);
199 }
200 finally {
201 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
202 }
203
204 Session session = null;
205
206 try {
207 session = openSession();
208
209 if (tagsEntry.isCachedModel() || BatchSessionUtil.isEnabled()) {
210 Object staleObject = session.get(TagsEntryImpl.class,
211 tagsEntry.getPrimaryKeyObj());
212
213 if (staleObject != null) {
214 session.evict(staleObject);
215 }
216 }
217
218 session.delete(tagsEntry);
219
220 session.flush();
221 }
222 catch (Exception e) {
223 throw processException(e);
224 }
225 finally {
226 closeSession(session);
227 }
228
229 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
230
231 EntityCacheUtil.removeResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
232 TagsEntryImpl.class, tagsEntry.getPrimaryKey());
233
234 return tagsEntry;
235 }
236
237
240 public TagsEntry update(TagsEntry tagsEntry) throws SystemException {
241 if (_log.isWarnEnabled()) {
242 _log.warn(
243 "Using the deprecated update(TagsEntry tagsEntry) method. Use update(TagsEntry tagsEntry, boolean merge) instead.");
244 }
245
246 return update(tagsEntry, false);
247 }
248
249
262 public TagsEntry update(TagsEntry tagsEntry, boolean merge)
263 throws SystemException {
264 boolean isNew = tagsEntry.isNew();
265
266 for (ModelListener<TagsEntry> listener : listeners) {
267 if (isNew) {
268 listener.onBeforeCreate(tagsEntry);
269 }
270 else {
271 listener.onBeforeUpdate(tagsEntry);
272 }
273 }
274
275 tagsEntry = updateImpl(tagsEntry, merge);
276
277 for (ModelListener<TagsEntry> listener : listeners) {
278 if (isNew) {
279 listener.onAfterCreate(tagsEntry);
280 }
281 else {
282 listener.onAfterUpdate(tagsEntry);
283 }
284 }
285
286 return tagsEntry;
287 }
288
289 public TagsEntry updateImpl(
290 com.liferay.portlet.tags.model.TagsEntry tagsEntry, boolean merge)
291 throws SystemException {
292 Session session = null;
293
294 try {
295 session = openSession();
296
297 BatchSessionUtil.update(session, tagsEntry, merge);
298
299 tagsEntry.setNew(false);
300 }
301 catch (Exception e) {
302 throw processException(e);
303 }
304 finally {
305 closeSession(session);
306 }
307
308 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
309
310 EntityCacheUtil.putResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
311 TagsEntryImpl.class, tagsEntry.getPrimaryKey(), tagsEntry);
312
313 return tagsEntry;
314 }
315
316 public TagsEntry findByPrimaryKey(long entryId)
317 throws NoSuchEntryException, SystemException {
318 TagsEntry tagsEntry = fetchByPrimaryKey(entryId);
319
320 if (tagsEntry == null) {
321 if (_log.isWarnEnabled()) {
322 _log.warn("No TagsEntry exists with the primary key " +
323 entryId);
324 }
325
326 throw new NoSuchEntryException(
327 "No TagsEntry exists with the primary key " + entryId);
328 }
329
330 return tagsEntry;
331 }
332
333 public TagsEntry fetchByPrimaryKey(long entryId) throws SystemException {
334 TagsEntry tagsEntry = (TagsEntry)EntityCacheUtil.getResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
335 TagsEntryImpl.class, entryId, this);
336
337 if (tagsEntry == null) {
338 Session session = null;
339
340 try {
341 session = openSession();
342
343 tagsEntry = (TagsEntry)session.get(TagsEntryImpl.class,
344 new Long(entryId));
345 }
346 catch (Exception e) {
347 throw processException(e);
348 }
349 finally {
350 if (tagsEntry != null) {
351 cacheResult(tagsEntry);
352 }
353
354 closeSession(session);
355 }
356 }
357
358 return tagsEntry;
359 }
360
361 public List<TagsEntry> findByVocabularyId(long vocabularyId)
362 throws SystemException {
363 Object[] finderArgs = new Object[] { new Long(vocabularyId) };
364
365 List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_VOCABULARYID,
366 finderArgs, this);
367
368 if (list == null) {
369 Session session = null;
370
371 try {
372 session = openSession();
373
374 StringBuilder query = new StringBuilder();
375
376 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
377
378 query.append("tagsEntry.vocabularyId = ?");
379
380 query.append(" ");
381
382 query.append("ORDER BY ");
383
384 query.append("tagsEntry.name ASC");
385
386 Query q = session.createQuery(query.toString());
387
388 QueryPos qPos = QueryPos.getInstance(q);
389
390 qPos.add(vocabularyId);
391
392 list = q.list();
393 }
394 catch (Exception e) {
395 throw processException(e);
396 }
397 finally {
398 if (list == null) {
399 list = new ArrayList<TagsEntry>();
400 }
401
402 cacheResult(list);
403
404 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_VOCABULARYID,
405 finderArgs, list);
406
407 closeSession(session);
408 }
409 }
410
411 return list;
412 }
413
414 public List<TagsEntry> findByVocabularyId(long vocabularyId, int start,
415 int end) throws SystemException {
416 return findByVocabularyId(vocabularyId, start, end, null);
417 }
418
419 public List<TagsEntry> findByVocabularyId(long vocabularyId, int start,
420 int end, OrderByComparator obc) throws SystemException {
421 Object[] finderArgs = new Object[] {
422 new Long(vocabularyId),
423
424 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
425 };
426
427 List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_VOCABULARYID,
428 finderArgs, this);
429
430 if (list == null) {
431 Session session = null;
432
433 try {
434 session = openSession();
435
436 StringBuilder query = new StringBuilder();
437
438 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
439
440 query.append("tagsEntry.vocabularyId = ?");
441
442 query.append(" ");
443
444 if (obc != null) {
445 query.append("ORDER BY ");
446
447 String[] orderByFields = obc.getOrderByFields();
448
449 for (int i = 0; i < orderByFields.length; i++) {
450 query.append("tagsEntry.");
451 query.append(orderByFields[i]);
452
453 if (obc.isAscending()) {
454 query.append(" ASC");
455 }
456 else {
457 query.append(" DESC");
458 }
459
460 if ((i + 1) < orderByFields.length) {
461 query.append(", ");
462 }
463 }
464 }
465
466 else {
467 query.append("ORDER BY ");
468
469 query.append("tagsEntry.name ASC");
470 }
471
472 Query q = session.createQuery(query.toString());
473
474 QueryPos qPos = QueryPos.getInstance(q);
475
476 qPos.add(vocabularyId);
477
478 list = (List<TagsEntry>)QueryUtil.list(q, getDialect(), start,
479 end);
480 }
481 catch (Exception e) {
482 throw processException(e);
483 }
484 finally {
485 if (list == null) {
486 list = new ArrayList<TagsEntry>();
487 }
488
489 cacheResult(list);
490
491 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_VOCABULARYID,
492 finderArgs, list);
493
494 closeSession(session);
495 }
496 }
497
498 return list;
499 }
500
501 public TagsEntry findByVocabularyId_First(long vocabularyId,
502 OrderByComparator obc) throws NoSuchEntryException, SystemException {
503 List<TagsEntry> list = findByVocabularyId(vocabularyId, 0, 1, obc);
504
505 if (list.isEmpty()) {
506 StringBuilder msg = new StringBuilder();
507
508 msg.append("No TagsEntry exists with the key {");
509
510 msg.append("vocabularyId=" + vocabularyId);
511
512 msg.append(StringPool.CLOSE_CURLY_BRACE);
513
514 throw new NoSuchEntryException(msg.toString());
515 }
516 else {
517 return list.get(0);
518 }
519 }
520
521 public TagsEntry findByVocabularyId_Last(long vocabularyId,
522 OrderByComparator obc) throws NoSuchEntryException, SystemException {
523 int count = countByVocabularyId(vocabularyId);
524
525 List<TagsEntry> list = findByVocabularyId(vocabularyId, count - 1,
526 count, obc);
527
528 if (list.isEmpty()) {
529 StringBuilder msg = new StringBuilder();
530
531 msg.append("No TagsEntry exists with the key {");
532
533 msg.append("vocabularyId=" + vocabularyId);
534
535 msg.append(StringPool.CLOSE_CURLY_BRACE);
536
537 throw new NoSuchEntryException(msg.toString());
538 }
539 else {
540 return list.get(0);
541 }
542 }
543
544 public TagsEntry[] findByVocabularyId_PrevAndNext(long entryId,
545 long vocabularyId, OrderByComparator obc)
546 throws NoSuchEntryException, SystemException {
547 TagsEntry tagsEntry = findByPrimaryKey(entryId);
548
549 int count = countByVocabularyId(vocabularyId);
550
551 Session session = null;
552
553 try {
554 session = openSession();
555
556 StringBuilder query = new StringBuilder();
557
558 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
559
560 query.append("tagsEntry.vocabularyId = ?");
561
562 query.append(" ");
563
564 if (obc != null) {
565 query.append("ORDER BY ");
566
567 String[] orderByFields = obc.getOrderByFields();
568
569 for (int i = 0; i < orderByFields.length; i++) {
570 query.append("tagsEntry.");
571 query.append(orderByFields[i]);
572
573 if (obc.isAscending()) {
574 query.append(" ASC");
575 }
576 else {
577 query.append(" DESC");
578 }
579
580 if ((i + 1) < orderByFields.length) {
581 query.append(", ");
582 }
583 }
584 }
585
586 else {
587 query.append("ORDER BY ");
588
589 query.append("tagsEntry.name ASC");
590 }
591
592 Query q = session.createQuery(query.toString());
593
594 QueryPos qPos = QueryPos.getInstance(q);
595
596 qPos.add(vocabularyId);
597
598 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
599 tagsEntry);
600
601 TagsEntry[] array = new TagsEntryImpl[3];
602
603 array[0] = (TagsEntry)objArray[0];
604 array[1] = (TagsEntry)objArray[1];
605 array[2] = (TagsEntry)objArray[2];
606
607 return array;
608 }
609 catch (Exception e) {
610 throw processException(e);
611 }
612 finally {
613 closeSession(session);
614 }
615 }
616
617 public List<TagsEntry> findByP_V(long parentEntryId, long vocabularyId)
618 throws SystemException {
619 Object[] finderArgs = new Object[] {
620 new Long(parentEntryId), new Long(vocabularyId)
621 };
622
623 List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_P_V,
624 finderArgs, this);
625
626 if (list == null) {
627 Session session = null;
628
629 try {
630 session = openSession();
631
632 StringBuilder query = new StringBuilder();
633
634 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
635
636 query.append("tagsEntry.parentEntryId = ?");
637
638 query.append(" AND ");
639
640 query.append("tagsEntry.vocabularyId = ?");
641
642 query.append(" ");
643
644 query.append("ORDER BY ");
645
646 query.append("tagsEntry.name ASC");
647
648 Query q = session.createQuery(query.toString());
649
650 QueryPos qPos = QueryPos.getInstance(q);
651
652 qPos.add(parentEntryId);
653
654 qPos.add(vocabularyId);
655
656 list = q.list();
657 }
658 catch (Exception e) {
659 throw processException(e);
660 }
661 finally {
662 if (list == null) {
663 list = new ArrayList<TagsEntry>();
664 }
665
666 cacheResult(list);
667
668 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_P_V, finderArgs,
669 list);
670
671 closeSession(session);
672 }
673 }
674
675 return list;
676 }
677
678 public List<TagsEntry> findByP_V(long parentEntryId, long vocabularyId,
679 int start, int end) throws SystemException {
680 return findByP_V(parentEntryId, vocabularyId, start, end, null);
681 }
682
683 public List<TagsEntry> findByP_V(long parentEntryId, long vocabularyId,
684 int start, int end, OrderByComparator obc) throws SystemException {
685 Object[] finderArgs = new Object[] {
686 new Long(parentEntryId), new Long(vocabularyId),
687
688 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
689 };
690
691 List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_P_V,
692 finderArgs, this);
693
694 if (list == null) {
695 Session session = null;
696
697 try {
698 session = openSession();
699
700 StringBuilder query = new StringBuilder();
701
702 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
703
704 query.append("tagsEntry.parentEntryId = ?");
705
706 query.append(" AND ");
707
708 query.append("tagsEntry.vocabularyId = ?");
709
710 query.append(" ");
711
712 if (obc != null) {
713 query.append("ORDER BY ");
714
715 String[] orderByFields = obc.getOrderByFields();
716
717 for (int i = 0; i < orderByFields.length; i++) {
718 query.append("tagsEntry.");
719 query.append(orderByFields[i]);
720
721 if (obc.isAscending()) {
722 query.append(" ASC");
723 }
724 else {
725 query.append(" DESC");
726 }
727
728 if ((i + 1) < orderByFields.length) {
729 query.append(", ");
730 }
731 }
732 }
733
734 else {
735 query.append("ORDER BY ");
736
737 query.append("tagsEntry.name ASC");
738 }
739
740 Query q = session.createQuery(query.toString());
741
742 QueryPos qPos = QueryPos.getInstance(q);
743
744 qPos.add(parentEntryId);
745
746 qPos.add(vocabularyId);
747
748 list = (List<TagsEntry>)QueryUtil.list(q, getDialect(), start,
749 end);
750 }
751 catch (Exception e) {
752 throw processException(e);
753 }
754 finally {
755 if (list == null) {
756 list = new ArrayList<TagsEntry>();
757 }
758
759 cacheResult(list);
760
761 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_P_V,
762 finderArgs, list);
763
764 closeSession(session);
765 }
766 }
767
768 return list;
769 }
770
771 public TagsEntry findByP_V_First(long parentEntryId, long vocabularyId,
772 OrderByComparator obc) throws NoSuchEntryException, SystemException {
773 List<TagsEntry> list = findByP_V(parentEntryId, vocabularyId, 0, 1, obc);
774
775 if (list.isEmpty()) {
776 StringBuilder msg = new StringBuilder();
777
778 msg.append("No TagsEntry exists with the key {");
779
780 msg.append("parentEntryId=" + parentEntryId);
781
782 msg.append(", ");
783 msg.append("vocabularyId=" + vocabularyId);
784
785 msg.append(StringPool.CLOSE_CURLY_BRACE);
786
787 throw new NoSuchEntryException(msg.toString());
788 }
789 else {
790 return list.get(0);
791 }
792 }
793
794 public TagsEntry findByP_V_Last(long parentEntryId, long vocabularyId,
795 OrderByComparator obc) throws NoSuchEntryException, SystemException {
796 int count = countByP_V(parentEntryId, vocabularyId);
797
798 List<TagsEntry> list = findByP_V(parentEntryId, vocabularyId,
799 count - 1, count, obc);
800
801 if (list.isEmpty()) {
802 StringBuilder msg = new StringBuilder();
803
804 msg.append("No TagsEntry exists with the key {");
805
806 msg.append("parentEntryId=" + parentEntryId);
807
808 msg.append(", ");
809 msg.append("vocabularyId=" + vocabularyId);
810
811 msg.append(StringPool.CLOSE_CURLY_BRACE);
812
813 throw new NoSuchEntryException(msg.toString());
814 }
815 else {
816 return list.get(0);
817 }
818 }
819
820 public TagsEntry[] findByP_V_PrevAndNext(long entryId, long parentEntryId,
821 long vocabularyId, OrderByComparator obc)
822 throws NoSuchEntryException, SystemException {
823 TagsEntry tagsEntry = findByPrimaryKey(entryId);
824
825 int count = countByP_V(parentEntryId, vocabularyId);
826
827 Session session = null;
828
829 try {
830 session = openSession();
831
832 StringBuilder query = new StringBuilder();
833
834 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
835
836 query.append("tagsEntry.parentEntryId = ?");
837
838 query.append(" AND ");
839
840 query.append("tagsEntry.vocabularyId = ?");
841
842 query.append(" ");
843
844 if (obc != null) {
845 query.append("ORDER BY ");
846
847 String[] orderByFields = obc.getOrderByFields();
848
849 for (int i = 0; i < orderByFields.length; i++) {
850 query.append("tagsEntry.");
851 query.append(orderByFields[i]);
852
853 if (obc.isAscending()) {
854 query.append(" ASC");
855 }
856 else {
857 query.append(" DESC");
858 }
859
860 if ((i + 1) < orderByFields.length) {
861 query.append(", ");
862 }
863 }
864 }
865
866 else {
867 query.append("ORDER BY ");
868
869 query.append("tagsEntry.name ASC");
870 }
871
872 Query q = session.createQuery(query.toString());
873
874 QueryPos qPos = QueryPos.getInstance(q);
875
876 qPos.add(parentEntryId);
877
878 qPos.add(vocabularyId);
879
880 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
881 tagsEntry);
882
883 TagsEntry[] array = new TagsEntryImpl[3];
884
885 array[0] = (TagsEntry)objArray[0];
886 array[1] = (TagsEntry)objArray[1];
887 array[2] = (TagsEntry)objArray[2];
888
889 return array;
890 }
891 catch (Exception e) {
892 throw processException(e);
893 }
894 finally {
895 closeSession(session);
896 }
897 }
898
899 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
900 throws SystemException {
901 Session session = null;
902
903 try {
904 session = openSession();
905
906 dynamicQuery.compile(session);
907
908 return dynamicQuery.list();
909 }
910 catch (Exception e) {
911 throw processException(e);
912 }
913 finally {
914 closeSession(session);
915 }
916 }
917
918 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
919 int start, int end) throws SystemException {
920 Session session = null;
921
922 try {
923 session = openSession();
924
925 dynamicQuery.setLimit(start, end);
926
927 dynamicQuery.compile(session);
928
929 return dynamicQuery.list();
930 }
931 catch (Exception e) {
932 throw processException(e);
933 }
934 finally {
935 closeSession(session);
936 }
937 }
938
939 public List<TagsEntry> findAll() throws SystemException {
940 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
941 }
942
943 public List<TagsEntry> findAll(int start, int end)
944 throws SystemException {
945 return findAll(start, end, null);
946 }
947
948 public List<TagsEntry> findAll(int start, int end, OrderByComparator obc)
949 throws SystemException {
950 Object[] finderArgs = new Object[] {
951 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
952 };
953
954 List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
955 finderArgs, this);
956
957 if (list == null) {
958 Session session = null;
959
960 try {
961 session = openSession();
962
963 StringBuilder query = new StringBuilder();
964
965 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry ");
966
967 if (obc != null) {
968 query.append("ORDER BY ");
969
970 String[] orderByFields = obc.getOrderByFields();
971
972 for (int i = 0; i < orderByFields.length; i++) {
973 query.append("tagsEntry.");
974 query.append(orderByFields[i]);
975
976 if (obc.isAscending()) {
977 query.append(" ASC");
978 }
979 else {
980 query.append(" DESC");
981 }
982
983 if ((i + 1) < orderByFields.length) {
984 query.append(", ");
985 }
986 }
987 }
988
989 else {
990 query.append("ORDER BY ");
991
992 query.append("tagsEntry.name ASC");
993 }
994
995 Query q = session.createQuery(query.toString());
996
997 if (obc == null) {
998 list = (List<TagsEntry>)QueryUtil.list(q, getDialect(),
999 start, end, false);
1000
1001 Collections.sort(list);
1002 }
1003 else {
1004 list = (List<TagsEntry>)QueryUtil.list(q, getDialect(),
1005 start, end);
1006 }
1007 }
1008 catch (Exception e) {
1009 throw processException(e);
1010 }
1011 finally {
1012 if (list == null) {
1013 list = new ArrayList<TagsEntry>();
1014 }
1015
1016 cacheResult(list);
1017
1018 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1019
1020 closeSession(session);
1021 }
1022 }
1023
1024 return list;
1025 }
1026
1027 public void removeByVocabularyId(long vocabularyId)
1028 throws SystemException {
1029 for (TagsEntry tagsEntry : findByVocabularyId(vocabularyId)) {
1030 remove(tagsEntry);
1031 }
1032 }
1033
1034 public void removeByP_V(long parentEntryId, long vocabularyId)
1035 throws SystemException {
1036 for (TagsEntry tagsEntry : findByP_V(parentEntryId, vocabularyId)) {
1037 remove(tagsEntry);
1038 }
1039 }
1040
1041 public void removeAll() throws SystemException {
1042 for (TagsEntry tagsEntry : findAll()) {
1043 remove(tagsEntry);
1044 }
1045 }
1046
1047 public int countByVocabularyId(long vocabularyId) throws SystemException {
1048 Object[] finderArgs = new Object[] { new Long(vocabularyId) };
1049
1050 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_VOCABULARYID,
1051 finderArgs, this);
1052
1053 if (count == null) {
1054 Session session = null;
1055
1056 try {
1057 session = openSession();
1058
1059 StringBuilder query = new StringBuilder();
1060
1061 query.append("SELECT COUNT(tagsEntry) ");
1062 query.append("FROM TagsEntry tagsEntry WHERE ");
1063
1064 query.append("tagsEntry.vocabularyId = ?");
1065
1066 query.append(" ");
1067
1068 Query q = session.createQuery(query.toString());
1069
1070 QueryPos qPos = QueryPos.getInstance(q);
1071
1072 qPos.add(vocabularyId);
1073
1074 count = (Long)q.uniqueResult();
1075 }
1076 catch (Exception e) {
1077 throw processException(e);
1078 }
1079 finally {
1080 if (count == null) {
1081 count = Long.valueOf(0);
1082 }
1083
1084 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_VOCABULARYID,
1085 finderArgs, count);
1086
1087 closeSession(session);
1088 }
1089 }
1090
1091 return count.intValue();
1092 }
1093
1094 public int countByP_V(long parentEntryId, long vocabularyId)
1095 throws SystemException {
1096 Object[] finderArgs = new Object[] {
1097 new Long(parentEntryId), new Long(vocabularyId)
1098 };
1099
1100 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_P_V,
1101 finderArgs, this);
1102
1103 if (count == null) {
1104 Session session = null;
1105
1106 try {
1107 session = openSession();
1108
1109 StringBuilder query = new StringBuilder();
1110
1111 query.append("SELECT COUNT(tagsEntry) ");
1112 query.append("FROM TagsEntry tagsEntry WHERE ");
1113
1114 query.append("tagsEntry.parentEntryId = ?");
1115
1116 query.append(" AND ");
1117
1118 query.append("tagsEntry.vocabularyId = ?");
1119
1120 query.append(" ");
1121
1122 Query q = session.createQuery(query.toString());
1123
1124 QueryPos qPos = QueryPos.getInstance(q);
1125
1126 qPos.add(parentEntryId);
1127
1128 qPos.add(vocabularyId);
1129
1130 count = (Long)q.uniqueResult();
1131 }
1132 catch (Exception e) {
1133 throw processException(e);
1134 }
1135 finally {
1136 if (count == null) {
1137 count = Long.valueOf(0);
1138 }
1139
1140 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_P_V, finderArgs,
1141 count);
1142
1143 closeSession(session);
1144 }
1145 }
1146
1147 return count.intValue();
1148 }
1149
1150 public int countAll() throws SystemException {
1151 Object[] finderArgs = new Object[0];
1152
1153 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1154 finderArgs, this);
1155
1156 if (count == null) {
1157 Session session = null;
1158
1159 try {
1160 session = openSession();
1161
1162 Query q = session.createQuery(
1163 "SELECT COUNT(tagsEntry) FROM TagsEntry tagsEntry");
1164
1165 count = (Long)q.uniqueResult();
1166 }
1167 catch (Exception e) {
1168 throw processException(e);
1169 }
1170 finally {
1171 if (count == null) {
1172 count = Long.valueOf(0);
1173 }
1174
1175 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1176 count);
1177
1178 closeSession(session);
1179 }
1180 }
1181
1182 return count.intValue();
1183 }
1184
1185 public List<com.liferay.portlet.tags.model.TagsAsset> getTagsAssets(long pk)
1186 throws SystemException {
1187 return getTagsAssets(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1188 }
1189
1190 public List<com.liferay.portlet.tags.model.TagsAsset> getTagsAssets(
1191 long pk, int start, int end) throws SystemException {
1192 return getTagsAssets(pk, start, end, null);
1193 }
1194
1195 public static final FinderPath FINDER_PATH_GET_TAGSASSETS = new FinderPath(com.liferay.portlet.tags.model.impl.TagsAssetModelImpl.ENTITY_CACHE_ENABLED,
1196 TagsEntryModelImpl.FINDER_CACHE_ENABLED_TAGSASSETS_TAGSENTRIES,
1197 "TagsAssets_TagsEntries", "getTagsAssets",
1198 new String[] {
1199 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
1200 "com.liferay.portal.kernel.util.OrderByComparator"
1201 });
1202
1203 public List<com.liferay.portlet.tags.model.TagsAsset> getTagsAssets(
1204 long pk, int start, int end, OrderByComparator obc)
1205 throws SystemException {
1206 Object[] finderArgs = new Object[] {
1207 new Long(pk), String.valueOf(start), String.valueOf(end),
1208 String.valueOf(obc)
1209 };
1210
1211 List<com.liferay.portlet.tags.model.TagsAsset> list = (List<com.liferay.portlet.tags.model.TagsAsset>)FinderCacheUtil.getResult(FINDER_PATH_GET_TAGSASSETS,
1212 finderArgs, this);
1213
1214 if (list == null) {
1215 Session session = null;
1216
1217 try {
1218 session = openSession();
1219
1220 StringBuilder sb = new StringBuilder();
1221
1222 sb.append(_SQL_GETTAGSASSETS);
1223
1224 if (obc != null) {
1225 sb.append("ORDER BY ");
1226 sb.append(obc.getOrderBy());
1227 }
1228
1229 String sql = sb.toString();
1230
1231 SQLQuery q = session.createSQLQuery(sql);
1232
1233 q.addEntity("TagsAsset",
1234 com.liferay.portlet.tags.model.impl.TagsAssetImpl.class);
1235
1236 QueryPos qPos = QueryPos.getInstance(q);
1237
1238 qPos.add(pk);
1239
1240 list = (List<com.liferay.portlet.tags.model.TagsAsset>)QueryUtil.list(q,
1241 getDialect(), start, end);
1242 }
1243 catch (Exception e) {
1244 throw processException(e);
1245 }
1246 finally {
1247 if (list == null) {
1248 list = new ArrayList<com.liferay.portlet.tags.model.TagsAsset>();
1249 }
1250
1251 tagsAssetPersistence.cacheResult(list);
1252
1253 FinderCacheUtil.putResult(FINDER_PATH_GET_TAGSASSETS,
1254 finderArgs, list);
1255
1256 closeSession(session);
1257 }
1258 }
1259
1260 return list;
1261 }
1262
1263 public static final FinderPath FINDER_PATH_GET_TAGSASSETS_SIZE = new FinderPath(com.liferay.portlet.tags.model.impl.TagsAssetModelImpl.ENTITY_CACHE_ENABLED,
1264 TagsEntryModelImpl.FINDER_CACHE_ENABLED_TAGSASSETS_TAGSENTRIES,
1265 "TagsAssets_TagsEntries", "getTagsAssetsSize",
1266 new String[] { Long.class.getName() });
1267
1268 public int getTagsAssetsSize(long pk) throws SystemException {
1269 Object[] finderArgs = new Object[] { new Long(pk) };
1270
1271 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_GET_TAGSASSETS_SIZE,
1272 finderArgs, this);
1273
1274 if (count == null) {
1275 Session session = null;
1276
1277 try {
1278 session = openSession();
1279
1280 SQLQuery q = session.createSQLQuery(_SQL_GETTAGSASSETSSIZE);
1281
1282 q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1283
1284 QueryPos qPos = QueryPos.getInstance(q);
1285
1286 qPos.add(pk);
1287
1288 count = (Long)q.uniqueResult();
1289 }
1290 catch (Exception e) {
1291 throw processException(e);
1292 }
1293 finally {
1294 if (count == null) {
1295 count = Long.valueOf(0);
1296 }
1297
1298 FinderCacheUtil.putResult(FINDER_PATH_GET_TAGSASSETS_SIZE,
1299 finderArgs, count);
1300
1301 closeSession(session);
1302 }
1303 }
1304
1305 return count.intValue();
1306 }
1307
1308 public static final FinderPath FINDER_PATH_CONTAINS_TAGSASSET = new FinderPath(com.liferay.portlet.tags.model.impl.TagsAssetModelImpl.ENTITY_CACHE_ENABLED,
1309 TagsEntryModelImpl.FINDER_CACHE_ENABLED_TAGSASSETS_TAGSENTRIES,
1310 "TagsAssets_TagsEntries", "containsTagsAsset",
1311 new String[] { Long.class.getName(), Long.class.getName() });
1312
1313 public boolean containsTagsAsset(long pk, long tagsAssetPK)
1314 throws SystemException {
1315 Object[] finderArgs = new Object[] { new Long(pk), new Long(tagsAssetPK) };
1316
1317 Boolean value = (Boolean)FinderCacheUtil.getResult(FINDER_PATH_CONTAINS_TAGSASSET,
1318 finderArgs, this);
1319
1320 if (value == null) {
1321 try {
1322 value = Boolean.valueOf(containsTagsAsset.contains(pk,
1323 tagsAssetPK));
1324 }
1325 catch (Exception e) {
1326 throw processException(e);
1327 }
1328 finally {
1329 if (value == null) {
1330 value = Boolean.FALSE;
1331 }
1332
1333 FinderCacheUtil.putResult(FINDER_PATH_CONTAINS_TAGSASSET,
1334 finderArgs, value);
1335 }
1336 }
1337
1338 return value.booleanValue();
1339 }
1340
1341 public boolean containsTagsAssets(long pk) throws SystemException {
1342 if (getTagsAssetsSize(pk) > 0) {
1343 return true;
1344 }
1345 else {
1346 return false;
1347 }
1348 }
1349
1350 public void addTagsAsset(long pk, long tagsAssetPK)
1351 throws SystemException {
1352 try {
1353 addTagsAsset.add(pk, tagsAssetPK);
1354 }
1355 catch (Exception e) {
1356 throw processException(e);
1357 }
1358 finally {
1359 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1360 }
1361 }
1362
1363 public void addTagsAsset(long pk,
1364 com.liferay.portlet.tags.model.TagsAsset tagsAsset)
1365 throws SystemException {
1366 try {
1367 addTagsAsset.add(pk, tagsAsset.getPrimaryKey());
1368 }
1369 catch (Exception e) {
1370 throw processException(e);
1371 }
1372 finally {
1373 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1374 }
1375 }
1376
1377 public void addTagsAssets(long pk, long[] tagsAssetPKs)
1378 throws SystemException {
1379 try {
1380 for (long tagsAssetPK : tagsAssetPKs) {
1381 addTagsAsset.add(pk, tagsAssetPK);
1382 }
1383 }
1384 catch (Exception e) {
1385 throw processException(e);
1386 }
1387 finally {
1388 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1389 }
1390 }
1391
1392 public void addTagsAssets(long pk,
1393 List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets)
1394 throws SystemException {
1395 try {
1396 for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1397 addTagsAsset.add(pk, tagsAsset.getPrimaryKey());
1398 }
1399 }
1400 catch (Exception e) {
1401 throw processException(e);
1402 }
1403 finally {
1404 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1405 }
1406 }
1407
1408 public void clearTagsAssets(long pk) throws SystemException {
1409 try {
1410 clearTagsAssets.clear(pk);
1411 }
1412 catch (Exception e) {
1413 throw processException(e);
1414 }
1415 finally {
1416 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1417 }
1418 }
1419
1420 public void removeTagsAsset(long pk, long tagsAssetPK)
1421 throws SystemException {
1422 try {
1423 removeTagsAsset.remove(pk, tagsAssetPK);
1424 }
1425 catch (Exception e) {
1426 throw processException(e);
1427 }
1428 finally {
1429 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1430 }
1431 }
1432
1433 public void removeTagsAsset(long pk,
1434 com.liferay.portlet.tags.model.TagsAsset tagsAsset)
1435 throws SystemException {
1436 try {
1437 removeTagsAsset.remove(pk, tagsAsset.getPrimaryKey());
1438 }
1439 catch (Exception e) {
1440 throw processException(e);
1441 }
1442 finally {
1443 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1444 }
1445 }
1446
1447 public void removeTagsAssets(long pk, long[] tagsAssetPKs)
1448 throws SystemException {
1449 try {
1450 for (long tagsAssetPK : tagsAssetPKs) {
1451 removeTagsAsset.remove(pk, tagsAssetPK);
1452 }
1453 }
1454 catch (Exception e) {
1455 throw processException(e);
1456 }
1457 finally {
1458 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1459 }
1460 }
1461
1462 public void removeTagsAssets(long pk,
1463 List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets)
1464 throws SystemException {
1465 try {
1466 for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1467 removeTagsAsset.remove(pk, tagsAsset.getPrimaryKey());
1468 }
1469 }
1470 catch (Exception e) {
1471 throw processException(e);
1472 }
1473 finally {
1474 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1475 }
1476 }
1477
1478 public void setTagsAssets(long pk, long[] tagsAssetPKs)
1479 throws SystemException {
1480 try {
1481 clearTagsAssets.clear(pk);
1482
1483 for (long tagsAssetPK : tagsAssetPKs) {
1484 addTagsAsset.add(pk, tagsAssetPK);
1485 }
1486 }
1487 catch (Exception e) {
1488 throw processException(e);
1489 }
1490 finally {
1491 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1492 }
1493 }
1494
1495 public void setTagsAssets(long pk,
1496 List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets)
1497 throws SystemException {
1498 try {
1499 clearTagsAssets.clear(pk);
1500
1501 for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1502 addTagsAsset.add(pk, tagsAsset.getPrimaryKey());
1503 }
1504 }
1505 catch (Exception e) {
1506 throw processException(e);
1507 }
1508 finally {
1509 FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1510 }
1511 }
1512
1513 public void afterPropertiesSet() {
1514 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1515 com.liferay.portal.util.PropsUtil.get(
1516 "value.object.listener.com.liferay.portlet.tags.model.TagsEntry")));
1517
1518 if (listenerClassNames.length > 0) {
1519 try {
1520 List<ModelListener<TagsEntry>> listenersList = new ArrayList<ModelListener<TagsEntry>>();
1521
1522 for (String listenerClassName : listenerClassNames) {
1523 listenersList.add((ModelListener<TagsEntry>)Class.forName(
1524 listenerClassName).newInstance());
1525 }
1526
1527 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1528 }
1529 catch (Exception e) {
1530 _log.error(e);
1531 }
1532 }
1533
1534 containsTagsAsset = new ContainsTagsAsset(this);
1535
1536 addTagsAsset = new AddTagsAsset(this);
1537 clearTagsAssets = new ClearTagsAssets(this);
1538 removeTagsAsset = new RemoveTagsAsset(this);
1539 }
1540
1541 @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsAssetPersistence.impl")
1542 protected com.liferay.portlet.tags.service.persistence.TagsAssetPersistence tagsAssetPersistence;
1543 @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsEntryPersistence.impl")
1544 protected com.liferay.portlet.tags.service.persistence.TagsEntryPersistence tagsEntryPersistence;
1545 @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsPropertyPersistence.impl")
1546 protected com.liferay.portlet.tags.service.persistence.TagsPropertyPersistence tagsPropertyPersistence;
1547 @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsSourcePersistence.impl")
1548 protected com.liferay.portlet.tags.service.persistence.TagsSourcePersistence tagsSourcePersistence;
1549 @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsVocabularyPersistence.impl")
1550 protected com.liferay.portlet.tags.service.persistence.TagsVocabularyPersistence tagsVocabularyPersistence;
1551 @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
1552 protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
1553 @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
1554 protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1555 protected ContainsTagsAsset containsTagsAsset;
1556 protected AddTagsAsset addTagsAsset;
1557 protected ClearTagsAssets clearTagsAssets;
1558 protected RemoveTagsAsset removeTagsAsset;
1559
1560 protected class ContainsTagsAsset {
1561 protected ContainsTagsAsset(TagsEntryPersistenceImpl persistenceImpl) {
1562 super();
1563
1564 _mappingSqlQuery = MappingSqlQueryFactoryUtil.getMappingSqlQuery(getDataSource(),
1565 _SQL_CONTAINSTAGSASSET,
1566 new int[] { Types.BIGINT, Types.BIGINT }, RowMapper.COUNT);
1567 }
1568
1569 protected boolean contains(long entryId, long assetId) {
1570 List<Integer> results = _mappingSqlQuery.execute(new Object[] {
1571 new Long(entryId), new Long(assetId)
1572 });
1573
1574 if (results.size() > 0) {
1575 Integer count = results.get(0);
1576
1577 if (count.intValue() > 0) {
1578 return true;
1579 }
1580 }
1581
1582 return false;
1583 }
1584
1585 private MappingSqlQuery _mappingSqlQuery;
1586 }
1587
1588 protected class AddTagsAsset {
1589 protected AddTagsAsset(TagsEntryPersistenceImpl persistenceImpl) {
1590 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
1591 "INSERT INTO TagsAssets_TagsEntries (entryId, assetId) VALUES (?, ?)",
1592 new int[] { Types.BIGINT, Types.BIGINT });
1593 _persistenceImpl = persistenceImpl;
1594 }
1595
1596 protected void add(long entryId, long assetId)
1597 throws SystemException {
1598 if (!_persistenceImpl.containsTagsAsset.contains(entryId, assetId)) {
1599 ModelListener<com.liferay.portlet.tags.model.TagsAsset>[] tagsAssetListeners =
1600 tagsAssetPersistence.getListeners();
1601
1602 for (ModelListener<TagsEntry> listener : listeners) {
1603 listener.onBeforeAddAssociation(entryId,
1604 com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1605 assetId);
1606 }
1607
1608 for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1609 listener.onBeforeAddAssociation(assetId,
1610 TagsEntry.class.getName(), entryId);
1611 }
1612
1613 _sqlUpdate.update(new Object[] {
1614 new Long(entryId), new Long(assetId)
1615 });
1616
1617 for (ModelListener<TagsEntry> listener : listeners) {
1618 listener.onAfterAddAssociation(entryId,
1619 com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1620 assetId);
1621 }
1622
1623 for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1624 listener.onAfterAddAssociation(assetId,
1625 TagsEntry.class.getName(), entryId);
1626 }
1627 }
1628 }
1629
1630 private SqlUpdate _sqlUpdate;
1631 private TagsEntryPersistenceImpl _persistenceImpl;
1632 }
1633
1634 protected class ClearTagsAssets {
1635 protected ClearTagsAssets(TagsEntryPersistenceImpl persistenceImpl) {
1636 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
1637 "DELETE FROM TagsAssets_TagsEntries WHERE entryId = ?",
1638 new int[] { Types.BIGINT });
1639 }
1640
1641 protected void clear(long entryId) throws SystemException {
1642 ModelListener<com.liferay.portlet.tags.model.TagsAsset>[] tagsAssetListeners =
1643 tagsAssetPersistence.getListeners();
1644
1645 List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets = null;
1646
1647 if ((listeners.length > 0) || (tagsAssetListeners.length > 0)) {
1648 tagsAssets = getTagsAssets(entryId);
1649
1650 for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1651 for (ModelListener<TagsEntry> listener : listeners) {
1652 listener.onBeforeRemoveAssociation(entryId,
1653 com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1654 tagsAsset.getPrimaryKey());
1655 }
1656
1657 for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1658 listener.onBeforeRemoveAssociation(tagsAsset.getPrimaryKey(),
1659 TagsEntry.class.getName(), entryId);
1660 }
1661 }
1662 }
1663
1664 _sqlUpdate.update(new Object[] { new Long(entryId) });
1665
1666 if ((listeners.length > 0) || (tagsAssetListeners.length > 0)) {
1667 for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1668 for (ModelListener<TagsEntry> listener : listeners) {
1669 listener.onAfterRemoveAssociation(entryId,
1670 com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1671 tagsAsset.getPrimaryKey());
1672 }
1673
1674 for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1675 listener.onAfterRemoveAssociation(tagsAsset.getPrimaryKey(),
1676 TagsEntry.class.getName(), entryId);
1677 }
1678 }
1679 }
1680 }
1681
1682 private SqlUpdate _sqlUpdate;
1683 }
1684
1685 protected class RemoveTagsAsset {
1686 protected RemoveTagsAsset(TagsEntryPersistenceImpl persistenceImpl) {
1687 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
1688 "DELETE FROM TagsAssets_TagsEntries WHERE entryId = ? AND assetId = ?",
1689 new int[] { Types.BIGINT, Types.BIGINT });
1690 _persistenceImpl = persistenceImpl;
1691 }
1692
1693 protected void remove(long entryId, long assetId)
1694 throws SystemException {
1695 if (_persistenceImpl.containsTagsAsset.contains(entryId, assetId)) {
1696 ModelListener<com.liferay.portlet.tags.model.TagsAsset>[] tagsAssetListeners =
1697 tagsAssetPersistence.getListeners();
1698
1699 for (ModelListener<TagsEntry> listener : listeners) {
1700 listener.onBeforeRemoveAssociation(entryId,
1701 com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1702 assetId);
1703 }
1704
1705 for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1706 listener.onBeforeRemoveAssociation(assetId,
1707 TagsEntry.class.getName(), entryId);
1708 }
1709
1710 _sqlUpdate.update(new Object[] {
1711 new Long(entryId), new Long(assetId)
1712 });
1713
1714 for (ModelListener<TagsEntry> listener : listeners) {
1715 listener.onAfterRemoveAssociation(entryId,
1716 com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1717 assetId);
1718 }
1719
1720 for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1721 listener.onAfterRemoveAssociation(assetId,
1722 TagsEntry.class.getName(), entryId);
1723 }
1724 }
1725 }
1726
1727 private SqlUpdate _sqlUpdate;
1728 private TagsEntryPersistenceImpl _persistenceImpl;
1729 }
1730
1731 private static final String _SQL_GETTAGSASSETS = "SELECT {TagsAsset.*} FROM TagsAsset INNER JOIN TagsAssets_TagsEntries ON (TagsAssets_TagsEntries.assetId = TagsAsset.assetId) WHERE (TagsAssets_TagsEntries.entryId = ?)";
1732 private static final String _SQL_GETTAGSASSETSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM TagsAssets_TagsEntries WHERE entryId = ?";
1733 private static final String _SQL_CONTAINSTAGSASSET = "SELECT COUNT(*) AS COUNT_VALUE FROM TagsAssets_TagsEntries WHERE entryId = ? AND assetId = ?";
1734 private static Log _log = LogFactoryUtil.getLog(TagsEntryPersistenceImpl.class);
1735}