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