001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service;
016    
017    import com.liferay.portal.NoSuchUserException;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.upload.UploadPortletRequest;
021    import com.liferay.portal.kernel.util.ArrayUtil;
022    import com.liferay.portal.kernel.util.Constants;
023    import com.liferay.portal.kernel.util.ParamUtil;
024    import com.liferay.portal.kernel.util.StringUtil;
025    import com.liferay.portal.kernel.util.Validator;
026    import com.liferay.portal.kernel.util.WebKeys;
027    import com.liferay.portal.kernel.workflow.WorkflowConstants;
028    import com.liferay.portal.model.PortletPreferencesIds;
029    import com.liferay.portal.model.User;
030    import com.liferay.portal.theme.ThemeDisplay;
031    import com.liferay.portal.util.PortalUtil;
032    import com.liferay.portlet.PortletPreferencesFactoryUtil;
033    import com.liferay.portlet.expando.util.ExpandoBridgeFactoryUtil;
034    
035    import java.io.Serializable;
036    
037    import java.util.ArrayList;
038    import java.util.Date;
039    import java.util.Enumeration;
040    import java.util.HashMap;
041    import java.util.List;
042    import java.util.Map;
043    
044    import javax.portlet.PortletRequest;
045    
046    import javax.servlet.http.HttpServletRequest;
047    
048    /**
049     * @author Brian Wing Shun Chan
050     * @author Raymond Aug??
051     */
052    public class ServiceContextFactory {
053    
054            public static ServiceContext getInstance(HttpServletRequest request)
055                    throws PortalException, SystemException {
056    
057                    ServiceContext serviceContext = new ServiceContext();
058    
059                    // Theme display
060    
061                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
062                            WebKeys.THEME_DISPLAY);
063    
064                    if (themeDisplay != null) {
065                            serviceContext.setCompanyId(themeDisplay.getCompanyId());
066                            serviceContext.setLanguageId(themeDisplay.getLanguageId());
067                            serviceContext.setLayoutFullURL(
068                                    PortalUtil.getCanonicalURL(
069                                            PortalUtil.getLayoutFullURL(themeDisplay), themeDisplay,
070                                            themeDisplay.getLayout(), true));
071                            serviceContext.setLayoutURL(
072                                    PortalUtil.getCanonicalURL(
073                                            PortalUtil.getLayoutURL(themeDisplay), themeDisplay,
074                                            themeDisplay.getLayout(), true));
075                            serviceContext.setPathMain(PortalUtil.getPathMain());
076                            serviceContext.setPathFriendlyURLPrivateGroup(
077                                    PortalUtil.getPathFriendlyURLPrivateGroup());
078                            serviceContext.setPathFriendlyURLPrivateUser(
079                                    PortalUtil.getPathFriendlyURLPrivateUser());
080                            serviceContext.setPathFriendlyURLPublic(
081                                    PortalUtil.getPathFriendlyURLPublic());
082                            serviceContext.setPlid(themeDisplay.getPlid());
083                            serviceContext.setPortalURL(PortalUtil.getPortalURL(request));
084                            serviceContext.setScopeGroupId(themeDisplay.getScopeGroupId());
085                            serviceContext.setSignedIn(themeDisplay.isSignedIn());
086                            serviceContext.setTimeZone(themeDisplay.getTimeZone());
087    
088                            User user = themeDisplay.getUser();
089    
090                            serviceContext.setUserDisplayURL(user.getDisplayURL(themeDisplay));
091                            serviceContext.setUserId(user.getUserId());
092                    }
093                    else {
094                            long companyId = PortalUtil.getCompanyId(request);
095    
096                            serviceContext.setCompanyId(companyId);
097    
098                            serviceContext.setPathFriendlyURLPrivateGroup(
099                                    PortalUtil.getPathFriendlyURLPrivateGroup());
100                            serviceContext.setPathFriendlyURLPrivateUser(
101                                    PortalUtil.getPathFriendlyURLPrivateUser());
102                            serviceContext.setPathFriendlyURLPublic(
103                                    PortalUtil.getPathFriendlyURLPublic());
104                            serviceContext.setPathMain(PortalUtil.getPathMain());
105    
106                            User user = null;
107    
108                            try {
109                                    user = PortalUtil.getUser(request);
110                            }
111                            catch (NoSuchUserException nsue) {
112    
113                                    // LPS-24160
114    
115                            }
116    
117                            if (user != null) {
118                                    serviceContext.setSignedIn(!user.isDefaultUser());
119                                    serviceContext.setUserId(user.getUserId());
120                            }
121                            else {
122                                    serviceContext.setSignedIn(false);
123                            }
124                    }
125    
126                    // Attributes
127    
128                    Map<String, Serializable> attributes =
129                            new HashMap<String, Serializable>();
130    
131                    Map<String, String[]> parameters = request.getParameterMap();
132    
133                    for (Map.Entry<String, String[]> entry : parameters.entrySet()) {
134                            String name = entry.getKey();
135                            String[] values = entry.getValue();
136    
137                            if (ArrayUtil.isNotEmpty(values)) {
138                                    if (values.length == 1) {
139                                            attributes.put(name, values[0]);
140                                    }
141                                    else {
142                                            attributes.put(name, values);
143                                    }
144                            }
145                    }
146    
147                    serviceContext.setAttributes(attributes);
148    
149                    // Command
150    
151                    String cmd = ParamUtil.getString(request, Constants.CMD);
152    
153                    serviceContext.setCommand(cmd);
154    
155                    // Current URL
156    
157                    String currentURL = PortalUtil.getCurrentURL(request);
158    
159                    serviceContext.setCurrentURL(currentURL);
160    
161                    // Form date
162    
163                    long formDateLong = ParamUtil.getLong(request, "formDate");
164    
165                    if (formDateLong > 0) {
166                            Date formDate = new Date(formDateLong);
167    
168                            serviceContext.setFormDate(formDate);
169                    }
170    
171                    // Permissions
172    
173                    boolean addGroupPermissions = ParamUtil.getBoolean(
174                            request, "addGroupPermissions");
175                    boolean addGuestPermissions = ParamUtil.getBoolean(
176                            request, "addGuestPermissions");
177                    String[] groupPermissions = PortalUtil.getGroupPermissions(request);
178                    String[] guestPermissions = PortalUtil.getGuestPermissions(request);
179    
180                    serviceContext.setAddGroupPermissions(addGroupPermissions);
181                    serviceContext.setAddGuestPermissions(addGuestPermissions);
182                    serviceContext.setGroupPermissions(groupPermissions);
183                    serviceContext.setGuestPermissions(guestPermissions);
184    
185                    // Portlet preferences ids
186    
187                    String portletId = PortalUtil.getPortletId(request);
188    
189                    if (Validator.isNotNull(portletId)) {
190                            PortletPreferencesIds portletPreferencesIds =
191                                    PortletPreferencesFactoryUtil.getPortletPreferencesIds(
192                                            request, portletId);
193    
194                            serviceContext.setPortletPreferencesIds(portletPreferencesIds);
195                    }
196    
197                    // Request
198    
199                    Map<String, String> headerMap = new HashMap<String, String>();
200    
201                    Enumeration<String> enu = request.getHeaderNames();
202    
203                    while (enu.hasMoreElements()) {
204                            String header = enu.nextElement();
205    
206                            String value = request.getHeader(header);
207    
208                            headerMap.put(header, value);
209                    }
210    
211                    serviceContext.setHeaders(headerMap);
212    
213                    serviceContext.setRemoteAddr(request.getRemoteAddr());
214                    serviceContext.setRemoteHost(request.getRemoteHost());
215                    serviceContext.setRequest(request);
216    
217                    // Asset
218    
219                    Map<String, String[]> parameterMap = request.getParameterMap();
220    
221                    List<Long> assetCategoryIdsList = new ArrayList<Long>();
222    
223                    boolean updateAssetCategoryIds = false;
224    
225                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
226                            String name = entry.getKey();
227    
228                            if (name.startsWith("assetCategoryIds")) {
229                                    updateAssetCategoryIds = true;
230    
231                                    long[] assetVocabularyAssetCategoryIds = StringUtil.split(
232                                            ParamUtil.getString(request, name), 0L);
233    
234                                    for (long assetCategoryId : assetVocabularyAssetCategoryIds) {
235                                            assetCategoryIdsList.add(assetCategoryId);
236                                    }
237                            }
238                    }
239    
240                    if (updateAssetCategoryIds) {
241                            long[] assetCategoryIds = ArrayUtil.toArray(
242                                    assetCategoryIdsList.toArray(
243                                            new Long[assetCategoryIdsList.size()]));
244    
245                            serviceContext.setAssetCategoryIds(assetCategoryIds);
246                    }
247    
248                    boolean assetEntryVisible = ParamUtil.getBoolean(
249                            request, "assetEntryVisible", true);
250    
251                    serviceContext.setAssetEntryVisible(assetEntryVisible);
252    
253                    String assetLinkEntryIdsString = request.getParameter(
254                            "assetLinksSearchContainerPrimaryKeys");
255    
256                    if (assetLinkEntryIdsString != null) {
257                            long[] assetLinkEntryIds = StringUtil.split(
258                                    assetLinkEntryIdsString, 0L);
259    
260                            serviceContext.setAssetLinkEntryIds(assetLinkEntryIds);
261                    }
262    
263                    String assetTagNamesString = request.getParameter("assetTagNames");
264    
265                    if (assetTagNamesString != null) {
266                            String[] assetTagNames = StringUtil.split(assetTagNamesString);
267    
268                            serviceContext.setAssetTagNames(assetTagNames);
269                    }
270    
271                    // Workflow
272    
273                    int workflowAction = ParamUtil.getInteger(
274                            request, "workflowAction", WorkflowConstants.ACTION_PUBLISH);
275    
276                    serviceContext.setWorkflowAction(workflowAction);
277    
278                    return serviceContext;
279            }
280    
281            public static ServiceContext getInstance(PortletRequest portletRequest)
282                    throws PortalException, SystemException {
283    
284                    // Theme display
285    
286                    ServiceContext serviceContext =
287                            ServiceContextThreadLocal.getServiceContext();
288    
289                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
290                            WebKeys.THEME_DISPLAY);
291    
292                    if (serviceContext != null) {
293                            serviceContext = (ServiceContext)serviceContext.clone();
294                    }
295                    else {
296                            serviceContext = new ServiceContext();
297    
298                            serviceContext.setCompanyId(themeDisplay.getCompanyId());
299                            serviceContext.setLanguageId(themeDisplay.getLanguageId());
300                            serviceContext.setLayoutFullURL(
301                                    PortalUtil.getLayoutFullURL(themeDisplay));
302                            serviceContext.setLayoutURL(PortalUtil.getLayoutURL(themeDisplay));
303                            serviceContext.setPathFriendlyURLPrivateGroup(
304                                    PortalUtil.getPathFriendlyURLPrivateGroup());
305                            serviceContext.setPathFriendlyURLPrivateUser(
306                                    PortalUtil.getPathFriendlyURLPrivateUser());
307                            serviceContext.setPathFriendlyURLPublic(
308                                    PortalUtil.getPathFriendlyURLPublic());
309                            serviceContext.setPathMain(PortalUtil.getPathMain());
310                            serviceContext.setPlid(themeDisplay.getPlid());
311                            serviceContext.setPortalURL(
312                                    PortalUtil.getPortalURL(portletRequest));
313                            serviceContext.setSignedIn(themeDisplay.isSignedIn());
314                            serviceContext.setTimeZone(themeDisplay.getTimeZone());
315    
316                            User user = themeDisplay.getUser();
317    
318                            serviceContext.setUserDisplayURL(user.getDisplayURL(themeDisplay));
319                            serviceContext.setUserId(user.getUserId());
320                    }
321    
322                    serviceContext.setScopeGroupId(themeDisplay.getScopeGroupId());
323    
324                    // Attributes
325    
326                    Map<String, Serializable> attributes =
327                            new HashMap<String, Serializable>();
328    
329                    Enumeration<String> enu = portletRequest.getParameterNames();
330    
331                    while (enu.hasMoreElements()) {
332                            String param = enu.nextElement();
333    
334                            String[] values = portletRequest.getParameterValues(param);
335    
336                            if (ArrayUtil.isNotEmpty(values)) {
337                                    if (values.length == 1) {
338                                            attributes.put(param, values[0]);
339                                    }
340                                    else {
341                                            attributes.put(param, values);
342                                    }
343                            }
344                    }
345    
346                    serviceContext.setAttributes(attributes);
347    
348                    // Command
349    
350                    String cmd = ParamUtil.getString(portletRequest, Constants.CMD);
351    
352                    serviceContext.setCommand(cmd);
353    
354                    // Current URL
355    
356                    String currentURL = PortalUtil.getCurrentURL(portletRequest);
357    
358                    serviceContext.setCurrentURL(currentURL);
359    
360                    // Form date
361    
362                    long formDateLong = ParamUtil.getLong(portletRequest, "formDate");
363    
364                    if (formDateLong > 0) {
365                            Date formDate = new Date(formDateLong);
366    
367                            serviceContext.setFormDate(formDate);
368                    }
369    
370                    // Permissions
371    
372                    boolean addGroupPermissions = ParamUtil.getBoolean(
373                            portletRequest, "addGroupPermissions");
374                    boolean addGuestPermissions = ParamUtil.getBoolean(
375                            portletRequest, "addGuestPermissions");
376                    String[] groupPermissions = PortalUtil.getGroupPermissions(
377                            portletRequest);
378                    String[] guestPermissions = PortalUtil.getGuestPermissions(
379                            portletRequest);
380    
381                    serviceContext.setAddGroupPermissions(addGroupPermissions);
382                    serviceContext.setAddGuestPermissions(addGuestPermissions);
383                    serviceContext.setGroupPermissions(groupPermissions);
384                    serviceContext.setGuestPermissions(guestPermissions);
385    
386                    // Portlet preferences ids
387    
388                    HttpServletRequest request = PortalUtil.getHttpServletRequest(
389                            portletRequest);
390    
391                    String portletId = PortalUtil.getPortletId(portletRequest);
392    
393                    PortletPreferencesIds portletPreferencesIds =
394                            PortletPreferencesFactoryUtil.getPortletPreferencesIds(
395                                    request, portletId);
396    
397                    serviceContext.setPortletPreferencesIds(portletPreferencesIds);
398    
399                    // Request
400    
401                    Map<String, String> headerMap = new HashMap<String, String>();
402    
403                    enu = request.getHeaderNames();
404    
405                    while (enu.hasMoreElements()) {
406                            String header = enu.nextElement();
407    
408                            String value = request.getHeader(header);
409    
410                            headerMap.put(header, value);
411                    }
412    
413                    serviceContext.setHeaders(headerMap);
414    
415                    serviceContext.setRemoteAddr(request.getRemoteAddr());
416                    serviceContext.setRemoteHost(request.getRemoteHost());
417                    serviceContext.setRequest(request);
418    
419                    // Asset
420    
421                    Map<String, String[]> parameterMap = portletRequest.getParameterMap();
422    
423                    List<Long> assetCategoryIdsList = new ArrayList<Long>();
424    
425                    boolean updateAssetCategoryIds = false;
426    
427                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
428                            String name = entry.getKey();
429    
430                            if (name.startsWith("assetCategoryIds")) {
431                                    updateAssetCategoryIds = true;
432    
433                                    long[] assetVocabularyAssetCategoryIds = StringUtil.split(
434                                            ParamUtil.getString(portletRequest, name), 0L);
435    
436                                    for (long assetCategoryId : assetVocabularyAssetCategoryIds) {
437                                            assetCategoryIdsList.add(assetCategoryId);
438                                    }
439                            }
440                    }
441    
442                    if (updateAssetCategoryIds) {
443                            long[] assetCategoryIds = ArrayUtil.toArray(
444                                    assetCategoryIdsList.toArray(
445                                            new Long[assetCategoryIdsList.size()]));
446    
447                            serviceContext.setAssetCategoryIds(assetCategoryIds);
448                    }
449    
450                    boolean assetEntryVisible = ParamUtil.getBoolean(
451                            portletRequest, "assetEntryVisible", true);
452    
453                    serviceContext.setAssetEntryVisible(assetEntryVisible);
454    
455                    String assetLinkEntryIdsString = request.getParameter(
456                            "assetLinksSearchContainerPrimaryKeys");
457    
458                    if (assetLinkEntryIdsString != null) {
459                            long[] assetLinkEntryIds = StringUtil.split(
460                                    assetLinkEntryIdsString, 0L);
461    
462                            serviceContext.setAssetLinkEntryIds(assetLinkEntryIds);
463                    }
464    
465                    String assetTagNamesString = request.getParameter("assetTagNames");
466    
467                    if (assetTagNamesString != null) {
468                            String[] assetTagNames = StringUtil.split(assetTagNamesString);
469    
470                            serviceContext.setAssetTagNames(assetTagNames);
471                    }
472    
473                    // Workflow
474    
475                    int workflowAction = ParamUtil.getInteger(
476                            portletRequest, "workflowAction", WorkflowConstants.ACTION_PUBLISH);
477    
478                    serviceContext.setWorkflowAction(workflowAction);
479    
480                    return serviceContext;
481            }
482    
483            public static ServiceContext getInstance(
484                            String className, PortletRequest portletRequest)
485                    throws PortalException, SystemException {
486    
487                    ServiceContext serviceContext = getInstance(portletRequest);
488    
489                    // Permissions
490    
491                    String[] groupPermissions = PortalUtil.getGroupPermissions(
492                            portletRequest, className);
493                    String[] guestPermissions = PortalUtil.getGuestPermissions(
494                            portletRequest, className);
495    
496                    if (groupPermissions != null) {
497                            serviceContext.setGroupPermissions(groupPermissions);
498                    }
499    
500                    if (guestPermissions != null) {
501                            serviceContext.setGuestPermissions(guestPermissions);
502                    }
503    
504                    // Expando
505    
506                    Map<String, Serializable> expandoBridgeAttributes =
507                            PortalUtil.getExpandoBridgeAttributes(
508                                    ExpandoBridgeFactoryUtil.getExpandoBridge(
509                                            serviceContext.getCompanyId(), className),
510                                    portletRequest);
511    
512                    serviceContext.setExpandoBridgeAttributes(expandoBridgeAttributes);
513    
514                    return serviceContext;
515            }
516    
517            public static ServiceContext getInstance(
518                            String className, UploadPortletRequest uploadPortletRequest)
519                    throws PortalException, SystemException {
520    
521                    ServiceContext serviceContext = getInstance(uploadPortletRequest);
522    
523                    // Permissions
524    
525                    String[] groupPermissions = PortalUtil.getGroupPermissions(
526                            uploadPortletRequest, className);
527                    String[] guestPermissions = PortalUtil.getGuestPermissions(
528                            uploadPortletRequest, className);
529    
530                    if (groupPermissions != null) {
531                            serviceContext.setGroupPermissions(groupPermissions);
532                    }
533    
534                    if (guestPermissions != null) {
535                            serviceContext.setGuestPermissions(guestPermissions);
536                    }
537    
538                    // Expando
539    
540                    Map<String, Serializable> expandoBridgeAttributes =
541                            PortalUtil.getExpandoBridgeAttributes(
542                                    ExpandoBridgeFactoryUtil.getExpandoBridge(
543                                            serviceContext.getCompanyId(), className),
544                                    uploadPortletRequest);
545    
546                    serviceContext.setExpandoBridgeAttributes(expandoBridgeAttributes);
547    
548                    return serviceContext;
549            }
550    
551    }