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.assetpublisher.util;
016    
017    import com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.dao.orm.Property;
020    import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
021    import com.liferay.portal.kernel.dao.orm.QueryUtil;
022    import com.liferay.portal.kernel.exception.PortalException;
023    import com.liferay.portal.kernel.exception.SystemException;
024    import com.liferay.portal.kernel.language.LanguageUtil;
025    import com.liferay.portal.kernel.log.Log;
026    import com.liferay.portal.kernel.log.LogFactoryUtil;
027    import com.liferay.portal.kernel.servlet.SessionMessages;
028    import com.liferay.portal.kernel.util.Accessor;
029    import com.liferay.portal.kernel.util.ArrayUtil;
030    import com.liferay.portal.kernel.util.GetterUtil;
031    import com.liferay.portal.kernel.util.HtmlUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.ListUtil;
034    import com.liferay.portal.kernel.util.LocaleUtil;
035    import com.liferay.portal.kernel.util.LocalizationUtil;
036    import com.liferay.portal.kernel.util.ParamUtil;
037    import com.liferay.portal.kernel.util.PrefsPropsUtil;
038    import com.liferay.portal.kernel.util.PrimitiveLongList;
039    import com.liferay.portal.kernel.util.PropsKeys;
040    import com.liferay.portal.kernel.util.StringPool;
041    import com.liferay.portal.kernel.util.StringUtil;
042    import com.liferay.portal.kernel.util.Validator;
043    import com.liferay.portal.kernel.xml.Document;
044    import com.liferay.portal.kernel.xml.Element;
045    import com.liferay.portal.kernel.xml.SAXReaderUtil;
046    import com.liferay.portal.model.Company;
047    import com.liferay.portal.model.Group;
048    import com.liferay.portal.model.GroupConstants;
049    import com.liferay.portal.model.Layout;
050    import com.liferay.portal.model.PortletConstants;
051    import com.liferay.portal.model.User;
052    import com.liferay.portal.security.auth.PrincipalException;
053    import com.liferay.portal.security.auth.PrincipalThreadLocal;
054    import com.liferay.portal.security.permission.ActionKeys;
055    import com.liferay.portal.security.permission.PermissionChecker;
056    import com.liferay.portal.service.GroupLocalServiceUtil;
057    import com.liferay.portal.service.LayoutLocalServiceUtil;
058    import com.liferay.portal.service.PortletPreferencesLocalServiceUtil;
059    import com.liferay.portal.service.SubscriptionLocalServiceUtil;
060    import com.liferay.portal.service.permission.GroupPermissionUtil;
061    import com.liferay.portal.service.permission.PortletPermissionUtil;
062    import com.liferay.portal.theme.ThemeDisplay;
063    import com.liferay.portal.util.PortalUtil;
064    import com.liferay.portal.util.PortletKeys;
065    import com.liferay.portal.util.PropsValues;
066    import com.liferay.portal.util.SubscriptionSender;
067    import com.liferay.portal.util.WebKeys;
068    import com.liferay.portlet.PortletPreferencesFactoryUtil;
069    import com.liferay.portlet.StrictPortletPreferencesImpl;
070    import com.liferay.portlet.asset.AssetRendererFactoryRegistryUtil;
071    import com.liferay.portlet.asset.model.AssetCategory;
072    import com.liferay.portlet.asset.model.AssetEntry;
073    import com.liferay.portlet.asset.model.AssetRenderer;
074    import com.liferay.portlet.asset.model.AssetRendererFactory;
075    import com.liferay.portlet.asset.model.AssetTag;
076    import com.liferay.portlet.asset.model.ClassType;
077    import com.liferay.portlet.asset.service.AssetCategoryLocalServiceUtil;
078    import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
079    import com.liferay.portlet.asset.service.AssetEntryServiceUtil;
080    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
081    import com.liferay.portlet.asset.service.persistence.AssetEntryQuery;
082    import com.liferay.portlet.expando.model.ExpandoBridge;
083    import com.liferay.portlet.sites.util.SitesUtil;
084    
085    import java.io.IOException;
086    import java.io.Serializable;
087    
088    import java.util.ArrayList;
089    import java.util.HashMap;
090    import java.util.HashSet;
091    import java.util.Iterator;
092    import java.util.LinkedHashMap;
093    import java.util.List;
094    import java.util.Locale;
095    import java.util.Map;
096    import java.util.Set;
097    import java.util.concurrent.ConcurrentHashMap;
098    
099    import javax.portlet.PortletException;
100    import javax.portlet.PortletPreferences;
101    import javax.portlet.PortletRequest;
102    
103    import javax.servlet.http.HttpServletRequest;
104    import javax.servlet.http.HttpSession;
105    
106    /**
107     * @author Raymond Aug??
108     * @author Julio Camarero
109     */
110    public class AssetPublisherImpl implements AssetPublisher {
111    
112            public AssetPublisherImpl() {
113                    for (String assetEntryQueryProcessorClassName :
114                                    PropsValues.ASSET_PUBLISHER_ASSET_ENTRY_QUERY_PROCESSORS) {
115    
116                            try {
117                                    AssetEntryQueryProcessor assetEntryQueryProcessor =
118                                            (AssetEntryQueryProcessor)InstanceFactory.newInstance(
119                                                    assetEntryQueryProcessorClassName);
120    
121                                    registerAssetQueryProcessor(
122                                            assetEntryQueryProcessorClassName,
123                                            assetEntryQueryProcessor);
124                            }
125                            catch (Exception e) {
126                                    _log.error(e, e);
127                            }
128                    }
129            }
130    
131            @Override
132            public void addAndStoreSelection(
133                            PortletRequest portletRequest, String className, long classPK,
134                            int assetEntryOrder)
135                    throws Exception {
136    
137                    String referringPortletResource = ParamUtil.getString(
138                            portletRequest, "referringPortletResource");
139    
140                    if (Validator.isNull(referringPortletResource)) {
141                            return;
142                    }
143    
144                    String rootPortletId = PortletConstants.getRootPortletId(
145                            referringPortletResource);
146    
147                    if (!rootPortletId.equals(PortletKeys.ASSET_PUBLISHER)) {
148                            return;
149                    }
150    
151                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
152                            WebKeys.THEME_DISPLAY);
153    
154                    Layout layout = LayoutLocalServiceUtil.getLayout(
155                            themeDisplay.getRefererPlid());
156    
157                    PortletPreferences portletPreferences =
158                            PortletPreferencesFactoryUtil.getStrictPortletSetup(
159                                    layout, referringPortletResource);
160    
161                    if (portletPreferences instanceof StrictPortletPreferencesImpl) {
162                            return;
163                    }
164    
165                    String selectionStyle = portletPreferences.getValue(
166                            "selectionStyle", "dynamic");
167    
168                    if (selectionStyle.equals("dynamic")) {
169                            return;
170                    }
171    
172                    AssetEntry assetEntry = AssetEntryLocalServiceUtil.getEntry(
173                            className, classPK);
174    
175                    addSelection(
176                            themeDisplay, portletPreferences, referringPortletResource,
177                            assetEntry.getEntryId(), assetEntryOrder, className);
178    
179                    portletPreferences.store();
180            }
181    
182            @Override
183            public void addRecentFolderId(
184                    PortletRequest portletRequest, String className, long classPK) {
185    
186                    _getRecentFolderIds(portletRequest).put(className, classPK);
187            }
188    
189            @Override
190            public void addSelection(
191                            PortletRequest portletRequest,
192                            PortletPreferences portletPreferences, String portletId)
193                    throws Exception {
194    
195                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
196                            WebKeys.THEME_DISPLAY);
197    
198                    long assetEntryId = ParamUtil.getLong(portletRequest, "assetEntryId");
199                    int assetEntryOrder = ParamUtil.getInteger(
200                            portletRequest, "assetEntryOrder");
201                    String assetEntryType = ParamUtil.getString(
202                            portletRequest, "assetEntryType");
203    
204                    addSelection(
205                            themeDisplay, portletPreferences, portletId, assetEntryId,
206                            assetEntryOrder, assetEntryType);
207            }
208    
209            @Override
210            public void addSelection(
211                            ThemeDisplay themeDisplay, PortletPreferences portletPreferences,
212                            String portletId, long assetEntryId, int assetEntryOrder,
213                            String assetEntryType)
214                    throws Exception {
215    
216                    AssetEntry assetEntry = AssetEntryLocalServiceUtil.getEntry(
217                            assetEntryId);
218    
219                    String[] assetEntryXmls = portletPreferences.getValues(
220                            "assetEntryXml", new String[0]);
221    
222                    String assetEntryXml = _getAssetEntryXml(
223                            assetEntryType, assetEntry.getClassUuid());
224    
225                    if (!ArrayUtil.contains(assetEntryXmls, assetEntryXml)) {
226                            if (assetEntryOrder > -1) {
227                                    assetEntryXmls[assetEntryOrder] = assetEntryXml;
228                            }
229                            else {
230                                    assetEntryXmls = ArrayUtil.append(
231                                            assetEntryXmls, assetEntryXml);
232                            }
233    
234                            portletPreferences.setValues("assetEntryXml", assetEntryXmls);
235                    }
236    
237                    long plid = themeDisplay.getRefererPlid();
238    
239                    if (plid == 0) {
240                            plid = themeDisplay.getPlid();
241                    }
242    
243                    List<AssetEntry> assetEntries = new ArrayList<AssetEntry>();
244    
245                    assetEntries.add(assetEntry);
246    
247                    notifySubscribers(portletPreferences, plid, portletId, assetEntries);
248            }
249    
250            @Override
251            public void addUserAttributes(
252                            User user, String[] customUserAttributeNames,
253                            AssetEntryQuery assetEntryQuery)
254                    throws Exception {
255    
256                    if ((user == null) || (customUserAttributeNames.length == 0)) {
257                            return;
258                    }
259    
260                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
261                            user.getCompanyId());
262    
263                    long[] allCategoryIds = assetEntryQuery.getAllCategoryIds();
264    
265                    PrimitiveLongList allCategoryIdsList = new PrimitiveLongList(
266                            allCategoryIds.length + customUserAttributeNames.length);
267    
268                    allCategoryIdsList.addAll(allCategoryIds);
269    
270                    for (String customUserAttributeName : customUserAttributeNames) {
271                            ExpandoBridge userCustomAttributes = user.getExpandoBridge();
272    
273                            Serializable userCustomFieldValue = null;
274    
275                            try {
276                                    userCustomFieldValue = userCustomAttributes.getAttribute(
277                                            customUserAttributeName);
278                            }
279                            catch (Exception e) {
280                            }
281    
282                            if (userCustomFieldValue == null) {
283                                    continue;
284                            }
285    
286                            String userCustomFieldValueString = userCustomFieldValue.toString();
287    
288                            List<AssetCategory> assetCategories =
289                                    AssetCategoryLocalServiceUtil.search(
290                                            companyGroup.getGroupId(), userCustomFieldValueString,
291                                            new String[0], QueryUtil.ALL_POS, QueryUtil.ALL_POS);
292    
293                            for (AssetCategory assetCategory : assetCategories) {
294                                    allCategoryIdsList.add(assetCategory.getCategoryId());
295                            }
296                    }
297    
298                    assetEntryQuery.setAllCategoryIds(allCategoryIdsList.getArray());
299            }
300    
301            @Override
302            public void checkAssetEntries() throws Exception {
303                    ActionableDynamicQuery actionableDynamicQuery =
304                            PortletPreferencesLocalServiceUtil.getActionableDynamicQuery();
305    
306                    actionableDynamicQuery.setAddCriteriaMethod(
307                            new ActionableDynamicQuery.AddCriteriaMethod() {
308    
309                                    @Override
310                                    public void addCriteria(DynamicQuery dynamicQuery) {
311                                            Property property = PropertyFactoryUtil.forName(
312                                                    "portletId");
313    
314                                            String portletId =
315                                                    PortletKeys.ASSET_PUBLISHER +
316                                                            PortletConstants.INSTANCE_SEPARATOR +
317                                                                    StringPool.PERCENT;
318    
319                                            dynamicQuery.add(property.like(portletId));
320                                    }
321    
322                            });
323                    actionableDynamicQuery.setPerformActionMethod(
324                            new ActionableDynamicQuery.PerformActionMethod() {
325    
326                                    @Override
327                                    public void performAction(Object object)
328                                            throws PortalException {
329    
330                                            _checkAssetEntries(
331                                                    (com.liferay.portal.model.PortletPreferences)object);
332                                    }
333    
334                            });
335    
336                    actionableDynamicQuery.performActions();
337            }
338    
339            @Override
340            public long[] getAssetCategoryIds(PortletPreferences portletPreferences)
341                    throws Exception {
342    
343                    long[] assetCategoryIds = new long[0];
344    
345                    for (int i = 0; true; i++) {
346                            String[] queryValues = portletPreferences.getValues(
347                                    "queryValues" + i, null);
348    
349                            if (ArrayUtil.isEmpty(queryValues)) {
350                                    break;
351                            }
352    
353                            boolean queryContains = GetterUtil.getBoolean(
354                                    portletPreferences.getValue(
355                                            "queryContains" + i, StringPool.BLANK));
356                            boolean queryAndOperator = GetterUtil.getBoolean(
357                                    portletPreferences.getValue(
358                                            "queryAndOperator" + i, StringPool.BLANK));
359                            String queryName = portletPreferences.getValue(
360                                    "queryName" + i, StringPool.BLANK);
361    
362                            if (Validator.equals(queryName, "assetCategories") &&
363                                    queryContains && queryAndOperator) {
364    
365                                    assetCategoryIds = GetterUtil.getLongValues(queryValues);
366                            }
367                    }
368    
369                    return assetCategoryIds;
370            }
371    
372            @Override
373            public List<AssetEntry> getAssetEntries(
374                    long[] groupIds, long[] classNameIds, String keywords, String userName,
375                    String title, String description, boolean advancedSearch,
376                    boolean andOperator, int start, int end, String orderByCol1,
377                    String orderByCol2, String orderByType1, String orderByType2) {
378    
379                    AssetEntryQuery assetEntryQuery = getAssetEntryQuery(
380                            groupIds, classNameIds, keywords, userName, title, description,
381                            advancedSearch, andOperator, start, end, orderByCol1, orderByCol2,
382                            orderByType1, orderByType2);
383    
384                    return AssetEntryLocalServiceUtil.getEntries(assetEntryQuery);
385            }
386    
387            @Override
388            public List<AssetEntry> getAssetEntries(
389                            PortletPreferences portletPreferences, Layout layout,
390                            long scopeGroupId, int max, boolean checkPermission)
391                    throws PortalException {
392    
393                    long[] groupIds = getGroupIds(portletPreferences, scopeGroupId, layout);
394    
395                    AssetEntryQuery assetEntryQuery = getAssetEntryQuery(
396                            portletPreferences, groupIds);
397    
398                    assetEntryQuery.setGroupIds(groupIds);
399    
400                    boolean anyAssetType = GetterUtil.getBoolean(
401                            portletPreferences.getValue("anyAssetType", null), true);
402    
403                    if (!anyAssetType) {
404                            long[] availableClassNameIds =
405                                    AssetRendererFactoryRegistryUtil.getClassNameIds(
406                                            layout.getCompanyId());
407    
408                            long[] classNameIds = getClassNameIds(
409                                    portletPreferences, availableClassNameIds);
410    
411                            assetEntryQuery.setClassNameIds(classNameIds);
412                    }
413    
414                    long[] classTypeIds = GetterUtil.getLongValues(
415                            portletPreferences.getValues("classTypeIds", null));
416    
417                    assetEntryQuery.setClassTypeIds(classTypeIds);
418    
419                    boolean enablePermissions = GetterUtil.getBoolean(
420                            portletPreferences.getValue("enablePermissions", null));
421    
422                    assetEntryQuery.setEnablePermissions(enablePermissions);
423    
424                    assetEntryQuery.setEnd(max);
425    
426                    boolean excludeZeroViewCount = GetterUtil.getBoolean(
427                            portletPreferences.getValue("excludeZeroViewCount", null));
428    
429                    assetEntryQuery.setExcludeZeroViewCount(excludeZeroViewCount);
430    
431                    boolean showOnlyLayoutAssets = GetterUtil.getBoolean(
432                            portletPreferences.getValue("showOnlyLayoutAssets", null));
433    
434                    if (showOnlyLayoutAssets) {
435                            assetEntryQuery.setLayout(layout);
436                    }
437    
438                    String orderByColumn1 = GetterUtil.getString(
439                            portletPreferences.getValue("orderByColumn1", "modifiedDate"));
440    
441                    assetEntryQuery.setOrderByCol1(orderByColumn1);
442    
443                    String orderByColumn2 = GetterUtil.getString(
444                            portletPreferences.getValue("orderByColumn2", "title"));
445    
446                    assetEntryQuery.setOrderByCol2(orderByColumn2);
447    
448                    String orderByType1 = GetterUtil.getString(
449                            portletPreferences.getValue("orderByType1", "DESC"));
450    
451                    assetEntryQuery.setOrderByType1(orderByType1);
452    
453                    String orderByType2 = GetterUtil.getString(
454                            portletPreferences.getValue("orderByType2", "ASC"));
455    
456                    assetEntryQuery.setOrderByType2(orderByType2);
457    
458                    assetEntryQuery.setStart(0);
459    
460                    if (checkPermission) {
461                            return AssetEntryServiceUtil.getEntries(assetEntryQuery);
462                    }
463                    else {
464                            return AssetEntryLocalServiceUtil.getEntries(assetEntryQuery);
465                    }
466            }
467    
468            @Override
469            public List<AssetEntry> getAssetEntries(
470                            PortletRequest portletRequest,
471                            PortletPreferences portletPreferences,
472                            PermissionChecker permissionChecker, long[] groupIds,
473                            boolean deleteMissingAssetEntries, boolean checkPermission)
474                    throws Exception {
475    
476                    String[] assetEntryXmls = portletPreferences.getValues(
477                            "assetEntryXml", new String[0]);
478    
479                    List<AssetEntry> assetEntries = new ArrayList<AssetEntry>();
480    
481                    List<String> missingAssetEntryUuids = new ArrayList<String>();
482    
483                    for (String assetEntryXml : assetEntryXmls) {
484                            Document document = SAXReaderUtil.read(assetEntryXml);
485    
486                            Element rootElement = document.getRootElement();
487    
488                            String assetEntryUuid = rootElement.elementText("asset-entry-uuid");
489    
490                            AssetEntry assetEntry = null;
491    
492                            for (long groupId : groupIds) {
493                                    assetEntry = AssetEntryLocalServiceUtil.fetchEntry(
494                                            groupId, assetEntryUuid);
495    
496                                    if (assetEntry != null) {
497                                            break;
498                                    }
499                            }
500    
501                            if (assetEntry == null) {
502                                    if (deleteMissingAssetEntries) {
503                                            missingAssetEntryUuids.add(assetEntryUuid);
504                                    }
505    
506                                    continue;
507                            }
508    
509                            if (!assetEntry.isVisible()) {
510                                    continue;
511                            }
512    
513                            AssetRendererFactory assetRendererFactory =
514                                    AssetRendererFactoryRegistryUtil.
515                                            getAssetRendererFactoryByClassName(
516                                                    assetEntry.getClassName());
517    
518                            AssetRenderer assetRenderer = assetRendererFactory.getAssetRenderer(
519                                    assetEntry.getClassPK());
520    
521                            if (!assetRendererFactory.isActive(
522                                            permissionChecker.getCompanyId())) {
523    
524                                    if (deleteMissingAssetEntries) {
525                                            missingAssetEntryUuids.add(assetEntryUuid);
526                                    }
527    
528                                    continue;
529                            }
530    
531                            if (checkPermission &&
532                                    (!assetRenderer.isDisplayable() ||
533                                     !assetRenderer.hasViewPermission(permissionChecker))) {
534    
535                                    continue;
536                            }
537    
538                            assetEntries.add(assetEntry);
539                    }
540    
541                    if (deleteMissingAssetEntries) {
542                            AssetPublisherUtil.removeAndStoreSelection(
543                                    missingAssetEntryUuids, portletPreferences);
544    
545                            if (!missingAssetEntryUuids.isEmpty()) {
546                                    SessionMessages.add(
547                                            portletRequest, "deletedMissingAssetEntries",
548                                            missingAssetEntryUuids);
549                            }
550                    }
551    
552                    return assetEntries;
553            }
554    
555            @Override
556            public List<AssetEntry> getAssetEntries(
557                            PortletRequest portletRequest,
558                            PortletPreferences portletPreferences,
559                            PermissionChecker permissionChecker, long[] groupIds,
560                            long[] allCategoryIds, String[] allTagNames,
561                            boolean deleteMissingAssetEntries, boolean checkPermission)
562                    throws Exception {
563    
564                    List<AssetEntry> assetEntries = getAssetEntries(
565                            portletRequest, portletPreferences, permissionChecker, groupIds,
566                            deleteMissingAssetEntries, checkPermission);
567    
568                    if (assetEntries.isEmpty() ||
569                            (ArrayUtil.isEmpty(allCategoryIds) &&
570                             ArrayUtil.isEmpty(allTagNames))) {
571    
572                            return assetEntries;
573                    }
574    
575                    if (!ArrayUtil.isEmpty(allCategoryIds)) {
576                            assetEntries = _filterAssetCategoriesAssetEntries(
577                                    assetEntries, allCategoryIds);
578                    }
579    
580                    if (!ArrayUtil.isEmpty(allTagNames)) {
581                            assetEntries = _filterAssetTagNamesAssetEntries(
582                                    assetEntries, allTagNames);
583                    }
584    
585                    return assetEntries;
586            }
587    
588            /**
589             * @deprecated As of 7.0.0, replaced by {@link
590             *             AssetPublisherImpl#getAssetEntries(PortletRequest,
591             *             PortletPreferences, PermissionChecker, long[], long[],
592             *             String[], boolean , boolean)}
593             */
594            @Deprecated
595            @Override
596            public List<AssetEntry> getAssetEntries(
597                            PortletRequest portletRequest,
598                            PortletPreferences portletPreferences,
599                            PermissionChecker permissionChecker, long[] groupIds,
600                            long[] allCategoryIds, String[] assetEntryXmls,
601                            String[] allTagNames, boolean deleteMissingAssetEntries,
602                            boolean checkPermission)
603                    throws Exception {
604    
605                    return getAssetEntries(
606                            portletRequest, portletPreferences, permissionChecker, groupIds,
607                            allCategoryIds, allTagNames, deleteMissingAssetEntries,
608                            checkPermission);
609            }
610    
611            /**
612             * @deprecated As of 7.0.0, replaced by {@link
613             *             AssetPublisherImpl#getAssetEntries(PortletRequest,
614             *             PortletPreferences, PermissionChecker, long[], boolean,
615             *             boolean)}
616             */
617            @Deprecated
618            @Override
619            public List<AssetEntry> getAssetEntries(
620                            PortletRequest portletRequest,
621                            PortletPreferences portletPreferences,
622                            PermissionChecker permissionChecker, long[] groupIds,
623                            String[] assetEntryXmls, boolean deleteMissingAssetEntries,
624                            boolean checkPermission)
625                    throws Exception {
626    
627                    return getAssetEntries(
628                            portletRequest, portletPreferences, permissionChecker, groupIds,
629                            deleteMissingAssetEntries, checkPermission);
630            }
631    
632            @Override
633            public int getAssetEntriesCount(
634                    long[] groupIds, long[] classNameIds, String keywords, String userName,
635                    String title, String description, boolean advancedSearch,
636                    boolean andOperator, int start, int end) {
637    
638                    AssetEntryQuery assetEntryQuery = getAssetEntryQuery(
639                            groupIds, classNameIds, keywords, userName, title, description,
640                            advancedSearch, andOperator, start, end, null, null, null, null);
641    
642                    return AssetEntryLocalServiceUtil.getEntriesCount(assetEntryQuery);
643            }
644    
645            /**
646             * @deprecated As of 7.0.0, replaced by {@link
647             *             AssetPublisherImpl#getAssetEntryQuery(PortletPreferences,
648             *             long[], long[], String[])}
649             */
650            @Deprecated
651            @Override
652            public AssetEntryQuery getAssetEntryQuery(
653                            PortletPreferences portletPreferences, long[] scopeGroupIds)
654                    throws PortalException {
655    
656                    return getAssetEntryQuery(
657                            portletPreferences, scopeGroupIds, null, null);
658            }
659    
660            @Override
661            public AssetEntryQuery getAssetEntryQuery(
662                            PortletPreferences portletPreferences, long[] scopeGroupIds,
663                            long[] overrideAllAssetCategoryIds,
664                            String[] overrideAllAssetTagNames)
665                    throws PortalException {
666    
667                    AssetEntryQuery assetEntryQuery = new AssetEntryQuery();
668    
669                    long[] allAssetCategoryIds = new long[0];
670                    long[] anyAssetCategoryIds = new long[0];
671                    long[] notAllAssetCategoryIds = new long[0];
672                    long[] notAnyAssetCategoryIds = new long[0];
673    
674                    String[] allAssetTagNames = new String[0];
675                    String[] anyAssetTagNames = new String[0];
676                    String[] notAllAssetTagNames = new String[0];
677                    String[] notAnyAssetTagNames = new String[0];
678    
679                    for (int i = 0; true; i++) {
680                            String[] queryValues = portletPreferences.getValues(
681                                    "queryValues" + i, null);
682    
683                            if (ArrayUtil.isEmpty(queryValues)) {
684                                    break;
685                            }
686    
687                            boolean queryContains = GetterUtil.getBoolean(
688                                    portletPreferences.getValue(
689                                            "queryContains" + i, StringPool.BLANK));
690                            boolean queryAndOperator = GetterUtil.getBoolean(
691                                    portletPreferences.getValue(
692                                            "queryAndOperator" + i, StringPool.BLANK));
693                            String queryName = portletPreferences.getValue(
694                                    "queryName" + i, StringPool.BLANK);
695    
696                            if (Validator.equals(queryName, "assetCategories")) {
697                                    long[] assetCategoryIds = GetterUtil.getLongValues(queryValues);
698    
699                                    if (queryContains && queryAndOperator) {
700                                            allAssetCategoryIds = assetCategoryIds;
701                                    }
702                                    else if (queryContains && !queryAndOperator) {
703                                            anyAssetCategoryIds = assetCategoryIds;
704                                    }
705                                    else if (!queryContains && queryAndOperator) {
706                                            notAllAssetCategoryIds = assetCategoryIds;
707                                    }
708                                    else {
709                                            notAnyAssetCategoryIds = assetCategoryIds;
710                                    }
711                            }
712                            else {
713                                    if (queryContains && queryAndOperator) {
714                                            allAssetTagNames = queryValues;
715                                    }
716                                    else if (queryContains && !queryAndOperator) {
717                                            anyAssetTagNames = queryValues;
718                                    }
719                                    else if (!queryContains && queryAndOperator) {
720                                            notAllAssetTagNames = queryValues;
721                                    }
722                                    else {
723                                            notAnyAssetTagNames = queryValues;
724                                    }
725                            }
726                    }
727    
728                    if (overrideAllAssetCategoryIds != null) {
729                            allAssetCategoryIds = overrideAllAssetCategoryIds;
730                    }
731    
732                    assetEntryQuery.setAllCategoryIds(allAssetCategoryIds);
733    
734                    if (overrideAllAssetTagNames != null) {
735                            allAssetTagNames = overrideAllAssetTagNames;
736                    }
737    
738                    long[] siteGroupIds = getSiteGroupIds(scopeGroupIds);
739    
740                    for (String assetTagName : allAssetTagNames) {
741                            long[] allAssetTagIds = AssetTagLocalServiceUtil.getTagIds(
742                                    siteGroupIds, assetTagName);
743    
744                            assetEntryQuery.addAllTagIdsArray(allAssetTagIds);
745                    }
746    
747                    assetEntryQuery.setAnyCategoryIds(anyAssetCategoryIds);
748    
749                    long[] anyAssetTagIds = AssetTagLocalServiceUtil.getTagIds(
750                            siteGroupIds, anyAssetTagNames);
751    
752                    assetEntryQuery.setAnyTagIds(anyAssetTagIds);
753    
754                    assetEntryQuery.setListable(true);
755                    assetEntryQuery.setNotAllCategoryIds(notAllAssetCategoryIds);
756    
757                    for (String assetTagName : notAllAssetTagNames) {
758                            long[] notAllAssetTagIds = AssetTagLocalServiceUtil.getTagIds(
759                                    siteGroupIds, assetTagName);
760    
761                            assetEntryQuery.addNotAllTagIdsArray(notAllAssetTagIds);
762                    }
763    
764                    assetEntryQuery.setNotAnyCategoryIds(notAnyAssetCategoryIds);
765    
766                    long[] notAnyAssetTagIds = AssetTagLocalServiceUtil.getTagIds(
767                            siteGroupIds, notAnyAssetTagNames);
768    
769                    assetEntryQuery.setNotAnyTagIds(notAnyAssetTagIds);
770    
771                    return assetEntryQuery;
772            }
773    
774            @Override
775            public String[] getAssetTagNames(PortletPreferences portletPreferences)
776                    throws Exception {
777    
778                    String[] allAssetTagNames = new String[0];
779    
780                    for (int i = 0; true; i++) {
781                            String[] queryValues = portletPreferences.getValues(
782                                    "queryValues" + i, null);
783    
784                            if (ArrayUtil.isEmpty(queryValues)) {
785                                    break;
786                            }
787    
788                            boolean queryContains = GetterUtil.getBoolean(
789                                    portletPreferences.getValue(
790                                            "queryContains" + i, StringPool.BLANK));
791                            boolean queryAndOperator = GetterUtil.getBoolean(
792                                    portletPreferences.getValue(
793                                            "queryAndOperator" + i, StringPool.BLANK));
794                            String queryName = portletPreferences.getValue(
795                                    "queryName" + i, StringPool.BLANK);
796    
797                            if (!Validator.equals(queryName, "assetCategories") &&
798                                    queryContains && queryAndOperator) {
799    
800                                    allAssetTagNames = queryValues;
801                            }
802                    }
803    
804                    return allAssetTagNames;
805            }
806    
807            /**
808             * @deprecated As of 7.0.0, replaced by {@link
809             *             AssetPublisherImpl#getAssetTagNames(PortletPreferences)}
810             */
811            @Deprecated
812            @Override
813            public String[] getAssetTagNames(
814                            PortletPreferences portletPreferences, long scopeGroupId)
815                    throws Exception {
816    
817                    return getAssetTagNames(portletPreferences);
818            }
819    
820            @Override
821            public String getClassName(AssetRendererFactory assetRendererFactory) {
822                    Class<?> clazz = assetRendererFactory.getClass();
823    
824                    String className = clazz.getName();
825    
826                    int pos = className.lastIndexOf(StringPool.PERIOD);
827    
828                    return className.substring(pos + 1);
829            }
830    
831            @Override
832            public long[] getClassNameIds(
833                    PortletPreferences portletPreferences, long[] availableClassNameIds) {
834    
835                    boolean anyAssetType = GetterUtil.getBoolean(
836                            portletPreferences.getValue(
837                                    "anyAssetType", Boolean.TRUE.toString()));
838                    String selectionStyle = portletPreferences.getValue(
839                            "selectionStyle", "dynamic");
840    
841                    if (anyAssetType || selectionStyle.equals("manual")) {
842                            return availableClassNameIds;
843                    }
844    
845                    long defaultClassNameId = GetterUtil.getLong(
846                            portletPreferences.getValue("anyAssetType", null));
847    
848                    if (defaultClassNameId > 0) {
849                            return new long[] {defaultClassNameId};
850                    }
851    
852                    long[] classNameIds = GetterUtil.getLongValues(
853                            portletPreferences.getValues("classNameIds", null));
854    
855                    if (ArrayUtil.isNotEmpty(classNameIds)) {
856                            return classNameIds;
857                    }
858                    else {
859                            return availableClassNameIds;
860                    }
861            }
862    
863            @Override
864            public Long[] getClassTypeIds(
865                    PortletPreferences portletPreferences, String className,
866                    List<ClassType> availableClassTypes) {
867    
868                    Long[] availableClassTypeIds = new Long[availableClassTypes.size()];
869    
870                    for (int i = 0; i < availableClassTypeIds.length; i++) {
871                            ClassType classType = availableClassTypes.get(i);
872    
873                            availableClassTypeIds[i] = classType.getClassTypeId();
874                    }
875    
876                    return getClassTypeIds(
877                            portletPreferences, className, availableClassTypeIds);
878            }
879    
880            @Override
881            public Long[] getClassTypeIds(
882                    PortletPreferences portletPreferences, String className,
883                    Long[] availableClassTypeIds) {
884    
885                    boolean anyAssetType = GetterUtil.getBoolean(
886                            portletPreferences.getValue(
887                                    "anyClassType" + className, Boolean.TRUE.toString()));
888    
889                    if (anyAssetType) {
890                            return availableClassTypeIds;
891                    }
892    
893                    long defaultClassTypeId = GetterUtil.getLong(
894                            portletPreferences.getValue("anyClassType" + className, null));
895    
896                    if (defaultClassTypeId > 0) {
897                            return new Long[] {defaultClassTypeId};
898                    }
899    
900                    Long[] classTypeIds = ArrayUtil.toArray(
901                            StringUtil.split(
902                                    portletPreferences.getValue(
903                                            "classTypeIds" + className, null), 0L));
904    
905                    if (classTypeIds != null) {
906                            return classTypeIds;
907                    }
908                    else {
909                            return availableClassTypeIds;
910                    }
911            }
912    
913            @Override
914            public Map<Locale, String> getEmailAssetEntryAddedBodyMap(
915                    PortletPreferences portletPreferences) {
916    
917                    return LocalizationUtil.getLocalizationMap(
918                            portletPreferences, "emailAssetEntryAddedBody",
919                            PropsKeys.ASSET_PUBLISHER_EMAIL_ASSET_ENTRY_ADDED_BODY);
920            }
921    
922            @Override
923            public boolean getEmailAssetEntryAddedEnabled(
924                    PortletPreferences portletPreferences) {
925    
926                    String emailAssetEntryAddedEnabled = portletPreferences.getValue(
927                            "emailAssetEntryAddedEnabled", StringPool.BLANK);
928    
929                    if (Validator.isNotNull(emailAssetEntryAddedEnabled)) {
930                            return GetterUtil.getBoolean(emailAssetEntryAddedEnabled);
931                    }
932                    else {
933                            return PropsValues.ASSET_PUBLISHER_EMAIL_ASSET_ENTRY_ADDED_ENABLED;
934                    }
935            }
936    
937            @Override
938            public Map<Locale, String> getEmailAssetEntryAddedSubjectMap(
939                    PortletPreferences portletPreferences) {
940    
941                    return LocalizationUtil.getLocalizationMap(
942                            portletPreferences, "emailAssetEntryAddedSubject",
943                            PropsKeys.ASSET_PUBLISHER_EMAIL_ASSET_ENTRY_ADDED_SUBJECT);
944            }
945    
946            @Override
947            public Map<String, String> getEmailDefinitionTerms(
948                    PortletRequest portletRequest, String emailFromAddress,
949                    String emailFromName) {
950    
951                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
952                            WebKeys.THEME_DISPLAY);
953    
954                    Map<String, String> definitionTerms =
955                            new LinkedHashMap<String, String>();
956    
957                    definitionTerms.put(
958                            "[$ASSET_ENTRIES$]",
959                            LanguageUtil.get(themeDisplay.getLocale(), "the-list-of-assets"));
960                    definitionTerms.put(
961                            "[$COMPANY_ID$]",
962                            LanguageUtil.get(
963                                    themeDisplay.getLocale(),
964                                    "the-company-id-associated-with-the-assets"));
965                    definitionTerms.put(
966                            "[$COMPANY_MX$]",
967                            LanguageUtil.get(
968                                    themeDisplay.getLocale(),
969                                    "the-company-mx-associated-with-the-assets"));
970                    definitionTerms.put(
971                            "[$COMPANY_NAME$]",
972                            LanguageUtil.get(
973                                    themeDisplay.getLocale(),
974                                    "the-company-name-associated-with-the-assets"));
975                    definitionTerms.put(
976                            "[$FROM_ADDRESS$]", HtmlUtil.escape(emailFromAddress));
977                    definitionTerms.put("[$FROM_NAME$]", HtmlUtil.escape(emailFromName));
978    
979                    Company company = themeDisplay.getCompany();
980    
981                    definitionTerms.put("[$PORTAL_URL$]", company.getVirtualHostname());
982    
983                    definitionTerms.put(
984                            "[$PORTLET_NAME$]", PortalUtil.getPortletTitle(portletRequest));
985                    definitionTerms.put(
986                            "[$SITE_NAME$]",
987                            LanguageUtil.get(
988                                    themeDisplay.getLocale(),
989                                    "the-site-name-associated-with-the-assets"));
990                    definitionTerms.put(
991                            "[$TO_ADDRESS$]",
992                            LanguageUtil.get(
993                                    themeDisplay.getLocale(),
994                                    "the-address-of-the-email-recipient"));
995                    definitionTerms.put(
996                            "[$TO_NAME$]",
997                            LanguageUtil.get(
998                                    themeDisplay.getLocale(), "the-name-of-the-email-recipient"));
999    
1000                    return definitionTerms;
1001            }
1002    
1003            @Override
1004            public String getEmailFromAddress(
1005                    PortletPreferences portletPreferences, long companyId) {
1006    
1007                    return PortalUtil.getEmailFromAddress(
1008                            portletPreferences, companyId,
1009                            PropsValues.ASSET_PUBLISHER_EMAIL_FROM_ADDRESS);
1010            }
1011    
1012            @Override
1013            public String getEmailFromName(
1014                    PortletPreferences portletPreferences, long companyId) {
1015    
1016                    return PortalUtil.getEmailFromName(
1017                            portletPreferences, companyId,
1018                            PropsValues.ASSET_PUBLISHER_EMAIL_FROM_NAME);
1019            }
1020    
1021            @Override
1022            public long getGroupIdFromScopeId(
1023                            String scopeId, long siteGroupId, boolean privateLayout)
1024                    throws PortalException {
1025    
1026                    if (scopeId.startsWith(SCOPE_ID_CHILD_GROUP_PREFIX)) {
1027                            String scopeIdSuffix = scopeId.substring(
1028                                    SCOPE_ID_CHILD_GROUP_PREFIX.length());
1029    
1030                            long childGroupId = GetterUtil.getLong(scopeIdSuffix);
1031    
1032                            Group childGroup = GroupLocalServiceUtil.getGroup(childGroupId);
1033    
1034                            if (!childGroup.hasAncestor(siteGroupId)) {
1035                                    throw new PrincipalException();
1036                            }
1037    
1038                            return childGroupId;
1039                    }
1040                    else if (scopeId.startsWith(SCOPE_ID_GROUP_PREFIX)) {
1041                            String scopeIdSuffix = scopeId.substring(
1042                                    SCOPE_ID_GROUP_PREFIX.length());
1043    
1044                            if (scopeIdSuffix.equals(GroupConstants.DEFAULT)) {
1045                                    return siteGroupId;
1046                            }
1047    
1048                            long scopeGroupId = GetterUtil.getLong(scopeIdSuffix);
1049    
1050                            Group scopeGroup = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
1051    
1052                            if (scopeGroup == null) {
1053                                    throw new PrincipalException();
1054                            }
1055    
1056                            return scopeGroupId;
1057                    }
1058                    else if (scopeId.startsWith(SCOPE_ID_LAYOUT_UUID_PREFIX)) {
1059                            String layoutUuid = scopeId.substring(
1060                                    SCOPE_ID_LAYOUT_UUID_PREFIX.length());
1061    
1062                            Layout scopeIdLayout =
1063                                    LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
1064                                            layoutUuid, siteGroupId, privateLayout);
1065    
1066                            Group scopeIdGroup = null;
1067    
1068                            if (scopeIdLayout.hasScopeGroup()) {
1069                                    scopeIdGroup = scopeIdLayout.getScopeGroup();
1070                            }
1071                            else {
1072                                    scopeIdGroup = GroupLocalServiceUtil.addGroup(
1073                                            PrincipalThreadLocal.getUserId(),
1074                                            GroupConstants.DEFAULT_PARENT_GROUP_ID,
1075                                            Layout.class.getName(), scopeIdLayout.getPlid(),
1076                                            GroupConstants.DEFAULT_LIVE_GROUP_ID,
1077                                            String.valueOf(scopeIdLayout.getPlid()), null, 0, true,
1078                                            GroupConstants.DEFAULT_MEMBERSHIP_RESTRICTION, null, false,
1079                                            true, null);
1080                            }
1081    
1082                            return scopeIdGroup.getGroupId();
1083                    }
1084                    else if (scopeId.startsWith(SCOPE_ID_LAYOUT_PREFIX)) {
1085    
1086                            // Legacy portlet preferences
1087    
1088                            String scopeIdSuffix = scopeId.substring(
1089                                    SCOPE_ID_LAYOUT_PREFIX.length());
1090    
1091                            long scopeIdLayoutId = GetterUtil.getLong(scopeIdSuffix);
1092    
1093                            Layout scopeIdLayout = LayoutLocalServiceUtil.getLayout(
1094                                    siteGroupId, privateLayout, scopeIdLayoutId);
1095    
1096                            Group scopeIdGroup = scopeIdLayout.getScopeGroup();
1097    
1098                            return scopeIdGroup.getGroupId();
1099                    }
1100                    else if (scopeId.startsWith(SCOPE_ID_PARENT_GROUP_PREFIX)) {
1101                            String scopeIdSuffix = scopeId.substring(
1102                                    SCOPE_ID_PARENT_GROUP_PREFIX.length());
1103    
1104                            long parentGroupId = GetterUtil.getLong(scopeIdSuffix);
1105    
1106                            Group parentGroup = GroupLocalServiceUtil.getGroup(parentGroupId);
1107    
1108                            if (!SitesUtil.isContentSharingWithChildrenEnabled(parentGroup)) {
1109                                    throw new PrincipalException();
1110                            }
1111    
1112                            Group group = GroupLocalServiceUtil.getGroup(siteGroupId);
1113    
1114                            if (!group.hasAncestor(parentGroupId)) {
1115                                    throw new PrincipalException();
1116                            }
1117    
1118                            return parentGroupId;
1119                    }
1120                    else {
1121                            throw new IllegalArgumentException("Invalid scope ID " + scopeId);
1122                    }
1123            }
1124    
1125            @Override
1126            public long[] getGroupIds(
1127                    PortletPreferences portletPreferences, long scopeGroupId,
1128                    Layout layout) {
1129    
1130                    String[] scopeIds = portletPreferences.getValues(
1131                            "scopeIds", new String[] {SCOPE_ID_GROUP_PREFIX + scopeGroupId});
1132    
1133                    List<Long> groupIds = new ArrayList<Long>();
1134    
1135                    for (String scopeId : scopeIds) {
1136                            try {
1137                                    long groupId = getGroupIdFromScopeId(
1138                                            scopeId, scopeGroupId, layout.isPrivateLayout());
1139    
1140                                    groupIds.add(groupId);
1141                            }
1142                            catch (Exception e) {
1143                                    continue;
1144                            }
1145                    }
1146    
1147                    return ArrayUtil.toLongArray(groupIds);
1148            }
1149    
1150            @Override
1151            public long getRecentFolderId(
1152                    PortletRequest portletRequest, String className) {
1153    
1154                    Long classPK = _getRecentFolderIds(portletRequest).get(className);
1155    
1156                    if (classPK == null) {
1157                            return 0;
1158                    }
1159                    else {
1160                            return classPK.longValue();
1161                    }
1162            }
1163    
1164            @Override
1165            public String getScopeId(Group group, long scopeGroupId)
1166                    throws PortalException {
1167    
1168                    String key = null;
1169    
1170                    if (group.isLayout()) {
1171                            Layout layout = LayoutLocalServiceUtil.getLayout(
1172                                    group.getClassPK());
1173    
1174                            key = SCOPE_ID_LAYOUT_UUID_PREFIX + layout.getUuid();
1175                    }
1176                    else if (group.isLayoutPrototype() ||
1177                                     (group.getGroupId() == scopeGroupId)) {
1178    
1179                            key = SCOPE_ID_GROUP_PREFIX + GroupConstants.DEFAULT;
1180                    }
1181                    else {
1182                            Group scopeGroup = GroupLocalServiceUtil.getGroup(scopeGroupId);
1183    
1184                            if (scopeGroup.hasAncestor(group.getGroupId()) &&
1185                                    SitesUtil.isContentSharingWithChildrenEnabled(group)) {
1186    
1187                                    key = SCOPE_ID_PARENT_GROUP_PREFIX + group.getGroupId();
1188                            }
1189                            else if (group.hasAncestor(scopeGroup.getGroupId())) {
1190                                    key = SCOPE_ID_CHILD_GROUP_PREFIX + group.getGroupId();
1191                            }
1192                            else {
1193                                    key = SCOPE_ID_GROUP_PREFIX + group.getGroupId();
1194                            }
1195                    }
1196    
1197                    return key;
1198            }
1199    
1200            @Override
1201            public long getSubscriptionClassPK(long plid, String portletId)
1202                    throws PortalException {
1203    
1204                    com.liferay.portal.model.PortletPreferences portletPreferencesModel =
1205                            PortletPreferencesLocalServiceUtil.getPortletPreferences(
1206                                    PortletKeys.PREFS_OWNER_ID_DEFAULT,
1207                                    PortletKeys.PREFS_OWNER_TYPE_LAYOUT, plid, portletId);
1208    
1209                    return portletPreferencesModel.getPortletPreferencesId();
1210            }
1211    
1212            @Override
1213            public boolean isScopeIdSelectable(
1214                            PermissionChecker permissionChecker, String scopeId,
1215                            long companyGroupId, Layout layout)
1216                    throws PortalException {
1217    
1218                    long groupId = getGroupIdFromScopeId(
1219                            scopeId, layout.getGroupId(), layout.isPrivateLayout());
1220    
1221                    if (scopeId.startsWith(SCOPE_ID_CHILD_GROUP_PREFIX)) {
1222                            Group group = GroupLocalServiceUtil.getGroup(groupId);
1223    
1224                            if (!group.hasAncestor(layout.getGroupId())) {
1225                                    return false;
1226                            }
1227                    }
1228                    else if (scopeId.startsWith(SCOPE_ID_PARENT_GROUP_PREFIX)) {
1229                            Group siteGroup = layout.getGroup();
1230    
1231                            if (!siteGroup.hasAncestor(groupId)) {
1232                                    return false;
1233                            }
1234    
1235                            Group group = GroupLocalServiceUtil.getGroup(groupId);
1236    
1237                            if (SitesUtil.isContentSharingWithChildrenEnabled(group)) {
1238                                    return true;
1239                            }
1240    
1241                            if (!PrefsPropsUtil.getBoolean(
1242                                            layout.getCompanyId(),
1243                                            PropsKeys.
1244                                            SITES_CONTENT_SHARING_THROUGH_ADMINISTRATORS_ENABLED)) {
1245    
1246                                    return false;
1247                            }
1248    
1249                            return GroupPermissionUtil.contains(
1250                                    permissionChecker, group, ActionKeys.UPDATE);
1251                    }
1252                    else if (groupId != companyGroupId) {
1253                            return GroupPermissionUtil.contains(
1254                                    permissionChecker, groupId, ActionKeys.UPDATE);
1255                    }
1256    
1257                    return true;
1258            }
1259    
1260            @Override
1261            public boolean isSubscribed(
1262                            long companyId, long userId, long plid, String portletId)
1263                    throws PortalException {
1264    
1265                    return SubscriptionLocalServiceUtil.isSubscribed(
1266                            companyId, userId,
1267                            com.liferay.portal.model.PortletPreferences.class.getName(),
1268                            getSubscriptionClassPK(plid, portletId));
1269            }
1270    
1271            @Override
1272            public void notifySubscribers(
1273                            PortletPreferences portletPreferences, long plid, String portletId,
1274                            List<AssetEntry> assetEntries)
1275                    throws PortalException {
1276    
1277                    if (!getEmailAssetEntryAddedEnabled(portletPreferences) ||
1278                            assetEntries.isEmpty()) {
1279    
1280                            return;
1281                    }
1282    
1283                    AssetEntry assetEntry = assetEntries.get(0);
1284    
1285                    String fromName = getEmailFromName(
1286                            portletPreferences, assetEntry.getCompanyId());
1287                    String fromAddress = getEmailFromAddress(
1288                            portletPreferences, assetEntry.getCompanyId());
1289    
1290                    Map<Locale, String> localizedSubjectMap =
1291                            getEmailAssetEntryAddedSubjectMap(portletPreferences);
1292                    Map<Locale, String> localizedBodyMap = getEmailAssetEntryAddedBodyMap(
1293                            portletPreferences);
1294    
1295                    SubscriptionSender subscriptionSender = new SubscriptionSender();
1296    
1297                    subscriptionSender.setCompanyId(assetEntry.getCompanyId());
1298                    subscriptionSender.setContextAttributes(
1299                            "[$ASSET_ENTRIES$]",
1300                            ListUtil.toString(
1301                                    assetEntries, _titleAccessor, StringPool.COMMA_AND_SPACE));
1302                    subscriptionSender.setContextUserPrefix("ASSET_PUBLISHER");
1303                    subscriptionSender.setFrom(fromAddress, fromName);
1304                    subscriptionSender.setHtmlFormat(true);
1305                    subscriptionSender.setLocalizedBodyMap(localizedBodyMap);
1306                    subscriptionSender.setLocalizedSubjectMap(localizedSubjectMap);
1307                    subscriptionSender.setMailId("asset_entry", assetEntry.getEntryId());
1308                    subscriptionSender.setPortletId(PortletKeys.ASSET_PUBLISHER);
1309                    subscriptionSender.setReplyToAddress(fromAddress);
1310    
1311                    subscriptionSender.addPersistedSubscribers(
1312                            com.liferay.portal.model.PortletPreferences.class.getName(),
1313                            getSubscriptionClassPK(plid, portletId));
1314    
1315                    subscriptionSender.flushNotificationsAsync();
1316            }
1317    
1318            @Override
1319            public void processAssetEntryQuery(
1320                            User user, PortletPreferences portletPreferences,
1321                            AssetEntryQuery assetEntryQuery)
1322                    throws Exception {
1323    
1324                    for (AssetEntryQueryProcessor assetEntryQueryProcessor :
1325                                    _assetEntryQueryProcessor.values()) {
1326    
1327                            assetEntryQueryProcessor.processAssetEntryQuery(
1328                                    user, portletPreferences, assetEntryQuery);
1329                    }
1330            }
1331    
1332            @Override
1333            public void registerAssetQueryProcessor(
1334                    String assetQueryProcessorClassName,
1335                    AssetEntryQueryProcessor assetQueryProcessor) {
1336    
1337                    if (assetQueryProcessor == null) {
1338                            return;
1339                    }
1340    
1341                    _assetEntryQueryProcessor.put(
1342                            assetQueryProcessorClassName, assetQueryProcessor);
1343            }
1344    
1345            @Override
1346            public void removeAndStoreSelection(
1347                            List<String> assetEntryUuids, PortletPreferences portletPreferences)
1348                    throws Exception {
1349    
1350                    if (assetEntryUuids.isEmpty()) {
1351                            return;
1352                    }
1353    
1354                    String[] assetEntryXmls = portletPreferences.getValues(
1355                            "assetEntryXml", new String[0]);
1356    
1357                    List<String> assetEntryXmlsList = ListUtil.fromArray(assetEntryXmls);
1358    
1359                    Iterator<String> itr = assetEntryXmlsList.iterator();
1360    
1361                    while (itr.hasNext()) {
1362                            String assetEntryXml = itr.next();
1363    
1364                            Document document = SAXReaderUtil.read(assetEntryXml);
1365    
1366                            Element rootElement = document.getRootElement();
1367    
1368                            String assetEntryUuid = rootElement.elementText("asset-entry-uuid");
1369    
1370                            if (assetEntryUuids.contains(assetEntryUuid)) {
1371                                    itr.remove();
1372                            }
1373                    }
1374    
1375                    portletPreferences.setValues(
1376                            "assetEntryXml",
1377                            assetEntryXmlsList.toArray(new String[assetEntryXmlsList.size()]));
1378    
1379                    portletPreferences.store();
1380            }
1381    
1382            @Override
1383            public void removeRecentFolderId(
1384                    PortletRequest portletRequest, String className, long classPK) {
1385    
1386                    if (getRecentFolderId(portletRequest, className) == classPK) {
1387                            _getRecentFolderIds(portletRequest).remove(className);
1388                    }
1389            }
1390    
1391            @Override
1392            public void subscribe(
1393                            PermissionChecker permissionChecker, long groupId, long plid,
1394                            String portletId)
1395                    throws PortalException {
1396    
1397                    PortletPermissionUtil.check(
1398                            permissionChecker, plid, portletId, ActionKeys.SUBSCRIBE);
1399    
1400                    SubscriptionLocalServiceUtil.addSubscription(
1401                            permissionChecker.getUserId(), groupId,
1402                            com.liferay.portal.model.PortletPreferences.class.getName(),
1403                            getSubscriptionClassPK(plid, portletId));
1404            }
1405    
1406            @Override
1407            public void unregisterAssetQueryProcessor(
1408                    String assetQueryProcessorClassName) {
1409    
1410                    _assetEntryQueryProcessor.remove(assetQueryProcessorClassName);
1411            }
1412    
1413            @Override
1414            public void unsubscribe(
1415                            PermissionChecker permissionChecker, long plid, String portletId)
1416                    throws PortalException {
1417    
1418                    PortletPermissionUtil.check(
1419                            permissionChecker, plid, portletId, ActionKeys.SUBSCRIBE);
1420    
1421                    SubscriptionLocalServiceUtil.deleteSubscription(
1422                            permissionChecker.getUserId(),
1423                            com.liferay.portal.model.PortletPreferences.class.getName(),
1424                            getSubscriptionClassPK(plid, portletId));
1425            }
1426    
1427            protected AssetEntryQuery getAssetEntryQuery(
1428                    long[] groupIds, long[] classNameIds, String keywords, String userName,
1429                    String title, String description, boolean advancedSearch,
1430                    boolean andOperator, int start, int end, String orderByCol1,
1431                    String orderByCol2, String orderByType1, String orderByType2) {
1432    
1433                    AssetEntryQuery assetEntryQuery = new AssetEntryQuery();
1434    
1435                    if (advancedSearch) {
1436                            assetEntryQuery.setAndOperator(andOperator);
1437                            assetEntryQuery.setDescription(description);
1438                            assetEntryQuery.setTitle(title);
1439                            assetEntryQuery.setUserName(userName);
1440                    }
1441                    else {
1442                            assetEntryQuery.setKeywords(keywords);
1443                    }
1444    
1445                    assetEntryQuery.setClassNameIds(classNameIds);
1446                    assetEntryQuery.setEnd(end);
1447                    assetEntryQuery.setGroupIds(groupIds);
1448                    assetEntryQuery.setOrderByCol1(orderByCol1);
1449                    assetEntryQuery.setOrderByCol2(orderByCol2);
1450                    assetEntryQuery.setOrderByType1(orderByType1);
1451                    assetEntryQuery.setOrderByType2(orderByType2);
1452                    assetEntryQuery.setStart(start);
1453    
1454                    return assetEntryQuery;
1455            }
1456    
1457            protected long[] getSiteGroupIds(long[] groupIds) throws PortalException {
1458                    Set<Long> siteGroupIds = new HashSet<Long>();
1459    
1460                    for (long groupId : groupIds) {
1461                            siteGroupIds.add(PortalUtil.getSiteGroupId(groupId));
1462                    }
1463    
1464                    return ArrayUtil.toLongArray(siteGroupIds);
1465            }
1466    
1467            private void _checkAssetEntries(
1468                            com.liferay.portal.model.PortletPreferences
1469                                    portletPreferencesModel)
1470                    throws PortalException {
1471    
1472                    Layout layout = LayoutLocalServiceUtil.getLayout(
1473                            portletPreferencesModel.getPlid());
1474    
1475                    PortletPreferences portletPreferences =
1476                            PortletPreferencesFactoryUtil.fromXML(
1477                                    layout.getCompanyId(), portletPreferencesModel.getOwnerId(),
1478                                    portletPreferencesModel.getOwnerType(),
1479                                    portletPreferencesModel.getPlid(),
1480                                    portletPreferencesModel.getPortletId(),
1481                                    portletPreferencesModel.getPreferences());
1482    
1483                    if (!getEmailAssetEntryAddedEnabled(portletPreferences)) {
1484                            return;
1485                    }
1486    
1487                    List<AssetEntry> assetEntries = getAssetEntries(
1488                            portletPreferences, layout, layout.getGroupId(),
1489                            PropsValues.ASSET_PUBLISHER_DYNAMIC_SUBSCRIPTION_LIMIT, false);
1490    
1491                    if (assetEntries.isEmpty()) {
1492                            return;
1493                    }
1494    
1495                    long[] notifiedAssetEntryIds = GetterUtil.getLongValues(
1496                            portletPreferences.getValues("notifiedAssetEntryIds", null));
1497    
1498                    List<AssetEntry> newAssetEntries = new ArrayList<AssetEntry>();
1499    
1500                    for (int i = 0; i < assetEntries.size(); i++) {
1501                            AssetEntry assetEntry = assetEntries.get(i);
1502    
1503                            if (!ArrayUtil.contains(
1504                                            notifiedAssetEntryIds, assetEntry.getEntryId())) {
1505    
1506                                    newAssetEntries.add(assetEntry);
1507                            }
1508                    }
1509    
1510                    notifySubscribers(
1511                            portletPreferences, portletPreferencesModel.getPlid(),
1512                            portletPreferencesModel.getPortletId(), newAssetEntries);
1513    
1514                    try {
1515                            portletPreferences.setValues(
1516                                    "notifiedAssetEntryIds",
1517                                    StringUtil.split(
1518                                            ListUtil.toString(
1519                                                    assetEntries, AssetEntry.ENTRY_ID_ACCESSOR)));
1520    
1521                            portletPreferences.store();
1522                    }
1523                    catch (IOException ioe) {
1524                            throw new SystemException(ioe);
1525                    }
1526                    catch (PortletException pe) {
1527                            throw new SystemException(pe);
1528                    }
1529            }
1530    
1531            private List<AssetEntry> _filterAssetCategoriesAssetEntries(
1532                            List<AssetEntry> assetEntries, long[] assetCategoryIds)
1533                    throws Exception {
1534    
1535                    List<AssetEntry> filteredAssetEntries = new ArrayList<AssetEntry>();
1536    
1537                    for (AssetEntry assetEntry : assetEntries) {
1538                            if (ArrayUtil.containsAll(
1539                                            assetEntry.getCategoryIds(), assetCategoryIds)) {
1540    
1541                                    filteredAssetEntries.add(assetEntry);
1542                            }
1543                    }
1544    
1545                    return filteredAssetEntries;
1546            }
1547    
1548            private List<AssetEntry> _filterAssetTagNamesAssetEntries(
1549                            List<AssetEntry> assetEntries, String[] assetTagNames)
1550                    throws Exception {
1551    
1552                    List<AssetEntry> filteredAssetEntries = new ArrayList<AssetEntry>();
1553    
1554                    for (AssetEntry assetEntry : assetEntries) {
1555                            List<AssetTag> assetTags = assetEntry.getTags();
1556    
1557                            String[] assetEntryAssetTagNames = new String[assetTags.size()];
1558    
1559                            for (int i = 0; i < assetTags.size(); i++) {
1560                                    AssetTag assetTag = assetTags.get(i);
1561    
1562                                    assetEntryAssetTagNames[i] = assetTag.getName();
1563                            }
1564    
1565                            if (ArrayUtil.containsAll(assetEntryAssetTagNames, assetTagNames)) {
1566                                    filteredAssetEntries.add(assetEntry);
1567                            }
1568                    }
1569    
1570                    return filteredAssetEntries;
1571            }
1572    
1573            private String _getAssetEntryXml(
1574                    String assetEntryType, String assetEntryUuid) {
1575    
1576                    String xml = null;
1577    
1578                    try {
1579                            Document document = SAXReaderUtil.createDocument(StringPool.UTF8);
1580    
1581                            Element assetEntryElement = document.addElement("asset-entry");
1582    
1583                            Element assetEntryTypeElement = assetEntryElement.addElement(
1584                                    "asset-entry-type");
1585    
1586                            assetEntryTypeElement.addText(assetEntryType);
1587    
1588                            Element assetEntryUuidElement = assetEntryElement.addElement(
1589                                    "asset-entry-uuid");
1590    
1591                            assetEntryUuidElement.addText(assetEntryUuid);
1592    
1593                            xml = document.formattedString(StringPool.BLANK);
1594                    }
1595                    catch (IOException ioe) {
1596                            if (_log.isWarnEnabled()) {
1597                                    _log.warn(ioe);
1598                            }
1599                    }
1600    
1601                    return xml;
1602            }
1603    
1604            private Map<String, Long> _getRecentFolderIds(
1605                    PortletRequest portletRequest) {
1606    
1607                    HttpServletRequest request = PortalUtil.getHttpServletRequest(
1608                            portletRequest);
1609                    HttpSession session = request.getSession();
1610    
1611                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
1612                            WebKeys.THEME_DISPLAY);
1613    
1614                    String key =
1615                            AssetPublisherUtil.class + StringPool.UNDERLINE +
1616                                    themeDisplay.getScopeGroupId();
1617    
1618                    Map<String, Long> recentFolderIds =
1619                            (Map<String, Long>)session.getAttribute(key);
1620    
1621                    if (recentFolderIds == null) {
1622                            recentFolderIds = new HashMap<String, Long>();
1623                    }
1624    
1625                    session.setAttribute(key, recentFolderIds);
1626    
1627                    return recentFolderIds;
1628            }
1629    
1630            private static Log _log = LogFactoryUtil.getLog(AssetPublisherImpl.class);
1631    
1632            private Map<String, AssetEntryQueryProcessor> _assetEntryQueryProcessor =
1633                    new ConcurrentHashMap<String, AssetEntryQueryProcessor>();
1634    
1635            private Accessor<AssetEntry, String> _titleAccessor =
1636                    new Accessor<AssetEntry, String>() {
1637    
1638                            @Override
1639                            public String get(AssetEntry assetEntry) {
1640                                    return assetEntry.getTitle(LocaleUtil.getSiteDefault());
1641                            }
1642    
1643                            @Override
1644                            public Class<String> getAttributeClass() {
1645                                    return String.class;
1646                            }
1647    
1648                            @Override
1649                            public Class<AssetEntry> getTypeClass() {
1650                                    return AssetEntry.class;
1651                            }
1652    
1653                    };
1654    
1655    }