001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.asset.service.persistence.impl;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryPos;
018    import com.liferay.portal.kernel.dao.orm.QueryUtil;
019    import com.liferay.portal.kernel.dao.orm.SQLQuery;
020    import com.liferay.portal.kernel.dao.orm.Session;
021    import com.liferay.portal.kernel.dao.orm.Type;
022    import com.liferay.portal.kernel.exception.SystemException;
023    import com.liferay.portal.kernel.util.CharPool;
024    import com.liferay.portal.kernel.util.GetterUtil;
025    import com.liferay.portal.kernel.util.OrderByComparator;
026    import com.liferay.portal.kernel.util.StringBundler;
027    import com.liferay.portal.kernel.util.StringPool;
028    import com.liferay.portal.kernel.util.StringUtil;
029    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
030    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
031    import com.liferay.portal.util.PortalUtil;
032    import com.liferay.portlet.asset.NoSuchTagException;
033    import com.liferay.portlet.asset.model.AssetTag;
034    import com.liferay.portlet.asset.model.AssetTagConstants;
035    import com.liferay.portlet.asset.model.impl.AssetTagImpl;
036    import com.liferay.portlet.asset.service.persistence.AssetTagFinder;
037    import com.liferay.util.dao.orm.CustomSQLUtil;
038    
039    import java.util.ArrayList;
040    import java.util.Iterator;
041    import java.util.List;
042    
043    /**
044     * @author Brian Wing Shun Chan
045     * @author Bruno Farache
046     */
047    public class AssetTagFinderImpl
048            extends BasePersistenceImpl<AssetTag> implements AssetTagFinder {
049    
050            public static final String COUNT_BY_G_N =
051                    AssetTagFinder.class.getName() + ".countByG_N";
052    
053            public static final String COUNT_BY_G_C_N =
054                    AssetTagFinder.class.getName() + ".countByG_C_N";
055    
056            public static final String COUNT_BY_G_N_P =
057                    AssetTagFinder.class.getName() + ".countByG_N_P";
058    
059            public static final String FIND_BY_G_N =
060                    AssetTagFinder.class.getName() + ".findByG_N";
061    
062            public static final String FIND_BY_G_C_N =
063                    AssetTagFinder.class.getName() + ".findByG_C_N";
064    
065            public static final String FIND_BY_G_N_P =
066                    AssetTagFinder.class.getName() + ".findByG_N_P";
067    
068            public static final String FIND_BY_G_N_S_E =
069                    AssetTagFinder.class.getName() + ".findByG_N_S_E";
070    
071            @Override
072            public int countByG_C_N(long groupId, long classNameId, String name) {
073                    return doCountByG_C_N(groupId, classNameId, name, false);
074            }
075    
076            @Override
077            public int countByG_N_P(long groupId, String name, String[] tagProperties) {
078                    return doCountByG_N_P(groupId, name, tagProperties, false);
079            }
080    
081            @Override
082            public int filterCountByG_N(long groupId, String name) {
083                    return doCountByG_N(groupId, name, true);
084            }
085    
086            @Override
087            public int filterCountByG_C_N(long groupId, long classNameId, String name) {
088                    return doCountByG_C_N(groupId, classNameId, name, true);
089            }
090    
091            @Override
092            public int filterCountByG_N_P(
093                    long groupId, String name, String[] tagProperties) {
094    
095                    return doCountByG_N_P(groupId, name, tagProperties, true);
096            }
097    
098            @Override
099            public AssetTag filterFindByG_N(long groupId, String name)
100                    throws NoSuchTagException {
101    
102                    return doFindByG_N(groupId, name, true);
103            }
104    
105            @Override
106            public List<AssetTag> filterFindByG_C_N(
107                    long groupId, long classNameId, String name, int start, int end,
108                    OrderByComparator<AssetTag> obc) {
109    
110                    return doFindByG_C_N(groupId, classNameId, name, start, end, obc, true);
111            }
112    
113            @Override
114            public List<AssetTag> filterFindByG_N_P(
115                    long[] groupIds, String name, String[] tagProperties, int start,
116                    int end, OrderByComparator<AssetTag> obc) {
117    
118                    return doFindByG_N_P(
119                            groupIds, name, tagProperties, start, end, obc, true);
120            }
121    
122            @Override
123            public AssetTag findByG_N(long groupId, String name)
124                    throws NoSuchTagException {
125    
126                    return doFindByG_N(groupId, name, false);
127            }
128    
129            @Override
130            public List<AssetTag> findByG_C_N(
131                    long groupId, long classNameId, String name, int start, int end,
132                    OrderByComparator<AssetTag> obc) {
133    
134                    return doFindByG_C_N(
135                            groupId, classNameId, name, start, end, obc, false);
136            }
137    
138            @Override
139            public List<AssetTag> findByG_N_P(
140                    long[] groupIds, String name, String[] tagProperties, int start,
141                    int end, OrderByComparator<AssetTag> obc) {
142    
143                    return doFindByG_N_P(
144                            groupIds, name, tagProperties, start, end, obc, false);
145            }
146    
147            @Override
148            public List<AssetTag> findByG_N_S_E(
149                    long groupId, String name, int startPeriod, int endPeriod,
150                    int periodLength) {
151    
152                    Session session = null;
153    
154                    try {
155                            session = openSession();
156    
157                            String sql = CustomSQLUtil.get(FIND_BY_G_N_S_E);
158                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
159    
160                            QueryPos qPos = QueryPos.getInstance(q);
161    
162                            qPos.add(groupId);
163                            qPos.add(name);
164                            qPos.add(startPeriod);
165                            qPos.add(endPeriod);
166                            qPos.add(periodLength);
167                            qPos.add(endPeriod);
168    
169                            List<AssetTag> assetTags = new ArrayList<AssetTag>();
170    
171                            Iterator<Object[]> itr = q.iterate();
172    
173                            while (itr.hasNext()) {
174                                    Object[] array = itr.next();
175    
176                                    AssetTag assetTag = new AssetTagImpl();
177    
178                                    assetTag.setTagId(GetterUtil.getLong(array[0]));
179                                    assetTag.setName(GetterUtil.getString(array[1]));
180                                    assetTag.setAssetCount(GetterUtil.getInteger(array[2]));
181    
182                                    assetTags.add(assetTag);
183                            }
184    
185                            return assetTags;
186                    }
187                    catch (Exception e) {
188                            throw new SystemException(e);
189                    }
190                    finally {
191                            closeSession(session);
192                    }
193            }
194    
195            protected int doCountByG_N(
196                    long groupId, String name, boolean inlineSQLHelper) {
197    
198                    Session session = null;
199    
200                    try {
201                            session = openSession();
202    
203                            String sql = CustomSQLUtil.get(COUNT_BY_G_N);
204    
205                            if (inlineSQLHelper) {
206                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
207                                            sql, AssetTag.class.getName(), "AssetTag.tagId",
208                                            PortalUtil.getSiteGroupId(groupId));
209                            }
210    
211                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
212    
213                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
214    
215                            QueryPos qPos = QueryPos.getInstance(q);
216    
217                            qPos.add(groupId);
218    
219                            String lowerCaseName = StringUtil.toLowerCase(name);
220    
221                            qPos.add(lowerCaseName);
222    
223                            Iterator<Long> itr = q.iterate();
224    
225                            if (itr.hasNext()) {
226                                    Long count = itr.next();
227    
228                                    if (count != null) {
229                                            return count.intValue();
230                                    }
231                            }
232    
233                            return 0;
234                    }
235                    catch (Exception e) {
236                            throw new SystemException(e);
237                    }
238                    finally {
239                            closeSession(session);
240                    }
241            }
242    
243            protected int doCountByG_C_N(
244                    long groupId, long classNameId, String name, boolean inlineSQLHelper) {
245    
246                    Session session = null;
247    
248                    try {
249                            session = openSession();
250    
251                            String sql = CustomSQLUtil.get(COUNT_BY_G_C_N);
252    
253                            if (inlineSQLHelper) {
254                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
255                                            sql, AssetTag.class.getName(), "AssetTag.tagId",
256                                            PortalUtil.getSiteGroupId(groupId));
257                            }
258    
259                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
260    
261                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
262    
263                            QueryPos qPos = QueryPos.getInstance(q);
264    
265                            qPos.add(groupId);
266                            qPos.add(classNameId);
267    
268                            String lowerCaseName = StringUtil.toLowerCase(name);
269    
270                            qPos.add(lowerCaseName);
271                            qPos.add(lowerCaseName);
272    
273                            Iterator<Long> itr = q.iterate();
274    
275                            if (itr.hasNext()) {
276                                    Long count = itr.next();
277    
278                                    if (count != null) {
279                                            return count.intValue();
280                                    }
281                            }
282    
283                            return 0;
284                    }
285                    catch (Exception e) {
286                            throw new SystemException(e);
287                    }
288                    finally {
289                            closeSession(session);
290                    }
291            }
292    
293            protected int doCountByG_N_P(
294                    long groupId, String name, String[] tagProperties,
295                    boolean inlineSQLHelper) {
296    
297                    Session session = null;
298    
299                    try {
300                            session = openSession();
301    
302                            String sql = CustomSQLUtil.get(COUNT_BY_G_N_P);
303    
304                            sql = StringUtil.replace(sql, "[$JOIN$]", getJoin(tagProperties));
305    
306                            if (inlineSQLHelper) {
307                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
308                                            sql, AssetTag.class.getName(), "AssetTag.tagId", groupId);
309                            }
310    
311                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
312    
313                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
314    
315                            QueryPos qPos = QueryPos.getInstance(q);
316    
317                            setJoin(qPos, tagProperties);
318    
319                            qPos.add(groupId);
320    
321                            String lowerCaseName = StringUtil.toLowerCase(name);
322    
323                            qPos.add(lowerCaseName);
324                            qPos.add(lowerCaseName);
325    
326                            Iterator<Long> itr = q.iterate();
327    
328                            if (itr.hasNext()) {
329                                    Long count = itr.next();
330    
331                                    if (count != null) {
332                                            return count.intValue();
333                                    }
334                            }
335    
336                            return 0;
337                    }
338                    catch (Exception e) {
339                            throw new SystemException(e);
340                    }
341                    finally {
342                            closeSession(session);
343                    }
344            }
345    
346            protected AssetTag doFindByG_N(
347                            long groupId, String name, boolean inlineSQLHelper)
348                    throws NoSuchTagException {
349    
350                    name = StringUtil.toLowerCase(name.trim());
351    
352                    Session session = null;
353    
354                    try {
355                            session = openSession();
356    
357                            String sql = CustomSQLUtil.get(FIND_BY_G_N);
358    
359                            if (inlineSQLHelper) {
360                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
361                                            sql, AssetTag.class.getName(), "AssetTag.tagId", groupId);
362                            }
363    
364                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
365    
366                            q.addEntity("AssetTag", AssetTagImpl.class);
367    
368                            QueryPos qPos = QueryPos.getInstance(q);
369    
370                            qPos.add(groupId);
371    
372                            String lowerCaseName = StringUtil.toLowerCase(name);
373    
374                            qPos.add(lowerCaseName);
375    
376                            List<AssetTag> tags = q.list();
377    
378                            if (!tags.isEmpty()) {
379                                    return tags.get(0);
380                            }
381                    }
382                    catch (Exception e) {
383                            throw new SystemException(e);
384                    }
385                    finally {
386                            closeSession(session);
387                    }
388    
389                    StringBundler sb = new StringBundler(6);
390    
391                    sb.append("No AssetTag exists with the key ");
392                    sb.append("{groupId=");
393                    sb.append(groupId);
394                    sb.append(", name=");
395                    sb.append(name);
396                    sb.append("}");
397    
398                    throw new NoSuchTagException(sb.toString());
399            }
400    
401            protected List<AssetTag> doFindByG_C_N(
402                    long groupId, long classNameId, String name, int start, int end,
403                    OrderByComparator<AssetTag> obc, boolean inlineSQLHelper) {
404    
405                    Session session = null;
406    
407                    try {
408                            session = openSession();
409    
410                            String sql = CustomSQLUtil.get(FIND_BY_G_C_N);
411    
412                            sql = CustomSQLUtil.replaceOrderBy(sql, obc);
413    
414                            if (inlineSQLHelper) {
415                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
416                                            sql, AssetTag.class.getName(), "AssetTag.tagId",
417                                            PortalUtil.getSiteGroupId(groupId));
418                            }
419    
420                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
421    
422                            q.addEntity("AssetTag", AssetTagImpl.class);
423    
424                            QueryPos qPos = QueryPos.getInstance(q);
425    
426                            qPos.add(groupId);
427                            qPos.add(classNameId);
428    
429                            String lowerCaseName = StringUtil.toLowerCase(name);
430    
431                            qPos.add(lowerCaseName);
432                            qPos.add(lowerCaseName);
433    
434                            return (List<AssetTag>)QueryUtil.list(q, getDialect(), start, end);
435                    }
436                    catch (Exception e) {
437                            throw new SystemException(e);
438                    }
439                    finally {
440                            closeSession(session);
441                    }
442            }
443    
444            protected List<AssetTag> doFindByG_N_P(
445                    long[] groupIds, String name, String[] tagProperties, int start,
446                    int end, OrderByComparator<AssetTag> obc, boolean inlineSQLHelper) {
447    
448                    Session session = null;
449    
450                    try {
451                            session = openSession();
452    
453                            String sql = CustomSQLUtil.get(FIND_BY_G_N_P);
454    
455                            sql = StringUtil.replace(sql, "[$JOIN$]", getJoin(tagProperties));
456                            sql = StringUtil.replace(
457                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
458                            sql = CustomSQLUtil.replaceOrderBy(sql, obc);
459    
460                            if (inlineSQLHelper) {
461                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
462                                            sql, AssetTag.class.getName(), "AssetTag.tagId", groupIds);
463                            }
464    
465                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
466    
467                            q.addEntity("AssetTag", AssetTagImpl.class);
468    
469                            QueryPos qPos = QueryPos.getInstance(q);
470    
471                            setJoin(qPos, tagProperties);
472    
473                            qPos.add(groupIds);
474    
475                            String lowerCaseName = StringUtil.toLowerCase(name);
476    
477                            qPos.add(lowerCaseName);
478                            qPos.add(lowerCaseName);
479    
480                            return (List<AssetTag>)QueryUtil.list(q, getDialect(), start, end);
481                    }
482                    catch (Exception e) {
483                            throw new SystemException(e);
484                    }
485                    finally {
486                            closeSession(session);
487                    }
488            }
489    
490            protected String getGroupIds(long[] groupIds) {
491                    if (groupIds.length == 0) {
492                            return StringPool.BLANK;
493                    }
494    
495                    StringBundler sb = new StringBundler(groupIds.length * 2);
496    
497                    sb.append(StringPool.OPEN_PARENTHESIS);
498    
499                    for (int i = 0; i < groupIds.length; i++) {
500                            sb.append("groupId = ?");
501    
502                            if ((i + 1) < groupIds.length) {
503                                    sb.append(" OR ");
504                            }
505                    }
506    
507                    sb.append(") AND");
508    
509                    return sb.toString();
510            }
511    
512            protected String getJoin(String[] tagProperties) {
513                    if (tagProperties.length == 0) {
514                            return StringPool.BLANK;
515                    }
516    
517                    StringBundler sb = new StringBundler(tagProperties.length * 3 + 1);
518    
519                    sb.append(" INNER JOIN AssetTagProperty ON ");
520                    sb.append(" (AssetTagProperty.tagId = AssetTag.tagId) AND ");
521    
522                    for (int i = 0; i < tagProperties.length; i++) {
523                            sb.append("(AssetTagProperty.key_ = ? AND ");
524                            sb.append("AssetTagProperty.value = ?) ");
525    
526                            if ((i + 1) < tagProperties.length) {
527                                    sb.append(" AND ");
528                            }
529                    }
530    
531                    return sb.toString();
532            }
533    
534            protected void setJoin(QueryPos qPos, String[] tagProperties) {
535                    for (String tagProperty : tagProperties) {
536                            String[] tagPropertyParts = StringUtil.split(
537                                    tagProperty, AssetTagConstants.PROPERTY_KEY_VALUE_SEPARATOR);
538    
539                            if (tagPropertyParts.length <= 1) {
540                                    tagPropertyParts = StringUtil.split(
541                                            tagProperty, CharPool.COLON);
542                            }
543    
544                            String key = StringPool.BLANK;
545    
546                            if (tagPropertyParts.length > 0) {
547                                    key = GetterUtil.getString(tagPropertyParts[0]);
548                            }
549    
550                            String value = StringPool.BLANK;
551    
552                            if (tagPropertyParts.length > 1) {
553                                    value = GetterUtil.getString(tagPropertyParts[1]);
554                            }
555    
556                            qPos.add(key);
557                            qPos.add(value);
558                    }
559            }
560    
561    }