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.journal.action;
016    
017    import com.liferay.portal.LocaleException;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.log.Log;
020    import com.liferay.portal.kernel.log.LogFactoryUtil;
021    import com.liferay.portal.kernel.portlet.LiferayWindowState;
022    import com.liferay.portal.kernel.servlet.SessionErrors;
023    import com.liferay.portal.kernel.servlet.SessionMessages;
024    import com.liferay.portal.kernel.upload.LiferayFileItemException;
025    import com.liferay.portal.kernel.upload.UploadException;
026    import com.liferay.portal.kernel.upload.UploadPortletRequest;
027    import com.liferay.portal.kernel.util.Constants;
028    import com.liferay.portal.kernel.util.HtmlUtil;
029    import com.liferay.portal.kernel.util.HttpUtil;
030    import com.liferay.portal.kernel.util.LocaleUtil;
031    import com.liferay.portal.kernel.util.MapUtil;
032    import com.liferay.portal.kernel.util.ParamUtil;
033    import com.liferay.portal.kernel.util.StringPool;
034    import com.liferay.portal.kernel.util.StringUtil;
035    import com.liferay.portal.kernel.util.Validator;
036    import com.liferay.portal.kernel.workflow.WorkflowConstants;
037    import com.liferay.portal.model.Layout;
038    import com.liferay.portal.model.TrashedModel;
039    import com.liferay.portal.security.auth.PrincipalException;
040    import com.liferay.portal.service.ServiceContext;
041    import com.liferay.portal.service.ServiceContextFactory;
042    import com.liferay.portal.struts.PortletAction;
043    import com.liferay.portal.theme.ThemeDisplay;
044    import com.liferay.portal.util.PortalUtil;
045    import com.liferay.portal.util.WebKeys;
046    import com.liferay.portlet.PortletURLFactoryUtil;
047    import com.liferay.portlet.PortletURLImpl;
048    import com.liferay.portlet.asset.AssetCategoryException;
049    import com.liferay.portlet.asset.AssetTagException;
050    import com.liferay.portlet.assetpublisher.util.AssetPublisherUtil;
051    import com.liferay.portlet.documentlibrary.FileSizeException;
052    import com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
053    import com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException;
054    import com.liferay.portlet.dynamicdatamapping.StorageFieldRequiredException;
055    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
056    import com.liferay.portlet.dynamicdatamapping.service.DDMStructureLocalServiceUtil;
057    import com.liferay.portlet.journal.ArticleContentException;
058    import com.liferay.portlet.journal.ArticleContentSizeException;
059    import com.liferay.portlet.journal.ArticleDisplayDateException;
060    import com.liferay.portlet.journal.ArticleExpirationDateException;
061    import com.liferay.portlet.journal.ArticleIdException;
062    import com.liferay.portlet.journal.ArticleSmallImageNameException;
063    import com.liferay.portlet.journal.ArticleSmallImageSizeException;
064    import com.liferay.portlet.journal.ArticleTitleException;
065    import com.liferay.portlet.journal.ArticleTypeException;
066    import com.liferay.portlet.journal.ArticleVersionException;
067    import com.liferay.portlet.journal.DuplicateArticleIdException;
068    import com.liferay.portlet.journal.NoSuchArticleException;
069    import com.liferay.portlet.journal.asset.JournalArticleAssetRenderer;
070    import com.liferay.portlet.journal.model.JournalArticle;
071    import com.liferay.portlet.journal.service.JournalArticleServiceUtil;
072    import com.liferay.portlet.journal.service.JournalContentSearchLocalServiceUtil;
073    import com.liferay.portlet.journal.util.JournalUtil;
074    import com.liferay.portlet.trash.util.TrashUtil;
075    
076    import java.io.File;
077    
078    import java.util.ArrayList;
079    import java.util.Calendar;
080    import java.util.HashMap;
081    import java.util.List;
082    import java.util.Locale;
083    import java.util.Map;
084    
085    import javax.portlet.ActionRequest;
086    import javax.portlet.ActionResponse;
087    import javax.portlet.PortletConfig;
088    import javax.portlet.PortletPreferences;
089    import javax.portlet.PortletRequest;
090    import javax.portlet.PortletURL;
091    import javax.portlet.RenderRequest;
092    import javax.portlet.RenderResponse;
093    import javax.portlet.WindowState;
094    
095    import org.apache.struts.action.ActionForm;
096    import org.apache.struts.action.ActionForward;
097    import org.apache.struts.action.ActionMapping;
098    
099    /**
100     * @author Brian Wing Shun Chan
101     * @author Raymond Aug??
102     * @author Eduardo Lundgren
103     * @author Juan Fern??ndez
104     * @author Levente Hud??k
105     */
106    public class EditArticleAction extends PortletAction {
107    
108            public static final String VERSION_SEPARATOR = "_version_";
109    
110            @Override
111            public void processAction(
112                            ActionMapping actionMapping, ActionForm actionForm,
113                            PortletConfig portletConfig, ActionRequest actionRequest,
114                            ActionResponse actionResponse)
115                    throws Exception {
116    
117                    String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
118    
119                    JournalArticle article = null;
120                    String oldUrlTitle = StringPool.BLANK;
121    
122                    try {
123                            UploadException uploadException =
124                                    (UploadException)actionRequest.getAttribute(
125                                            WebKeys.UPLOAD_EXCEPTION);
126    
127                            if (uploadException != null) {
128                                    if (uploadException.isExceededLiferayFileItemSizeLimit()) {
129                                            throw new LiferayFileItemException();
130                                    }
131                                    else if (uploadException.isExceededSizeLimit()) {
132                                            throw new ArticleContentSizeException();
133                                    }
134    
135                                    throw new PortalException(uploadException.getCause());
136                            }
137                            else if (Validator.isNull(cmd)) {
138                                    return;
139                            }
140                            else if (cmd.equals(Constants.ADD) ||
141                                             cmd.equals(Constants.PREVIEW) ||
142                                             cmd.equals(Constants.UPDATE)) {
143    
144                                    Object[] contentAndImages = updateArticle(actionRequest);
145    
146                                    article = (JournalArticle)contentAndImages[0];
147                                    oldUrlTitle = ((String)contentAndImages[1]);
148                            }
149                            else if (cmd.equals(Constants.DELETE)) {
150                                    deleteArticles(actionRequest, false);
151                            }
152                            else if (cmd.equals(Constants.EXPIRE)) {
153                                    expireArticles(actionRequest);
154                            }
155                            else if (cmd.equals(Constants.MOVE_TO_TRASH)) {
156                                    deleteArticles(actionRequest, true);
157                            }
158                            else if (cmd.equals(Constants.SUBSCRIBE)) {
159                                    subscribeStructure(actionRequest);
160                            }
161                            else if (cmd.equals(Constants.UNSUBSCRIBE)) {
162                                    unsubscribeStructure(actionRequest);
163                            }
164    
165                            String redirect = ParamUtil.getString(actionRequest, "redirect");
166    
167                            int workflowAction = ParamUtil.getInteger(
168                                    actionRequest, "workflowAction",
169                                    WorkflowConstants.ACTION_PUBLISH);
170    
171                            String portletId = HttpUtil.getParameter(redirect, "p_p_id", false);
172    
173                            String namespace = PortalUtil.getPortletNamespace(portletId);
174    
175                            if (Validator.isNotNull(oldUrlTitle)) {
176                                    String oldRedirectParam = namespace + "redirect";
177    
178                                    String oldRedirect = HttpUtil.getParameter(
179                                            redirect, oldRedirectParam, false);
180    
181                                    if (Validator.isNotNull(oldRedirect)) {
182                                            String newRedirect = HttpUtil.decodeURL(oldRedirect);
183    
184                                            newRedirect = StringUtil.replace(
185                                                    newRedirect, oldUrlTitle, article.getUrlTitle());
186                                            newRedirect = StringUtil.replace(
187                                                    newRedirect, oldRedirectParam, "redirect");
188    
189                                            redirect = StringUtil.replace(
190                                                    redirect, oldRedirect, newRedirect);
191                                    }
192                            }
193    
194                            if (cmd.equals(Constants.DELETE) &&
195                                    !ActionUtil.hasArticle(actionRequest)) {
196    
197                                    String referringPortletResource = ParamUtil.getString(
198                                            actionRequest, "referringPortletResource");
199    
200                                    if (Validator.isNotNull(referringPortletResource)) {
201                                            setForward(
202                                                    actionRequest,
203                                                    "portlet.journal.asset.add_asset_redirect");
204    
205                                            return;
206                                    }
207                                    else {
208                                            ThemeDisplay themeDisplay =
209                                                    (ThemeDisplay)actionRequest.getAttribute(
210                                                            WebKeys.THEME_DISPLAY);
211    
212                                            PortletURL portletURL = PortletURLFactoryUtil.create(
213                                                    actionRequest, portletConfig.getPortletName(),
214                                                    themeDisplay.getPlid(), PortletRequest.RENDER_PHASE);
215    
216                                            redirect = portletURL.toString();
217                                    }
218                            }
219    
220                            if ((article != null) &&
221                                    (workflowAction == WorkflowConstants.ACTION_SAVE_DRAFT)) {
222    
223                                    redirect = getSaveAndContinueRedirect(
224                                            portletConfig, actionRequest, article, redirect);
225    
226                                    if (cmd.equals(Constants.PREVIEW)) {
227                                            SessionMessages.add(actionRequest, "previewRequested");
228    
229                                            hideDefaultSuccessMessage(actionRequest);
230                                    }
231    
232                                    sendRedirect(actionRequest, actionResponse, redirect);
233                            }
234                            else {
235                                    WindowState windowState = actionRequest.getWindowState();
236    
237                                    if (!windowState.equals(LiferayWindowState.POP_UP)) {
238                                            sendRedirect(actionRequest, actionResponse, redirect);
239                                    }
240                                    else {
241                                            redirect = PortalUtil.escapeRedirect(redirect);
242    
243                                            if (Validator.isNotNull(redirect)) {
244                                                    if (cmd.equals(Constants.ADD) && (article != null)) {
245                                                            redirect = HttpUtil.addParameter(
246                                                                    redirect, namespace + "className",
247                                                                    JournalArticle.class.getName());
248                                                            redirect = HttpUtil.addParameter(
249                                                                    redirect, namespace + "classPK",
250                                                                    JournalArticleAssetRenderer.getClassPK(
251                                                                            article));
252                                                    }
253    
254                                                    actionResponse.sendRedirect(redirect);
255                                            }
256                                    }
257                            }
258                    }
259                    catch (Exception e) {
260                            if (e instanceof NoSuchArticleException ||
261                                    e instanceof NoSuchStructureException ||
262                                    e instanceof NoSuchTemplateException ||
263                                    e instanceof PrincipalException) {
264    
265                                    SessionErrors.add(actionRequest, e.getClass());
266    
267                                    setForward(actionRequest, "portlet.journal.error");
268                            }
269                            else if (e instanceof ArticleContentException ||
270                                             e instanceof ArticleContentSizeException ||
271                                             e instanceof ArticleDisplayDateException ||
272                                             e instanceof ArticleExpirationDateException ||
273                                             e instanceof ArticleIdException ||
274                                             e instanceof ArticleSmallImageNameException ||
275                                             e instanceof ArticleSmallImageSizeException ||
276                                             e instanceof ArticleTitleException ||
277                                             e instanceof ArticleTypeException ||
278                                             e instanceof ArticleVersionException ||
279                                             e instanceof DuplicateArticleIdException ||
280                                             e instanceof FileSizeException ||
281                                             e instanceof LiferayFileItemException ||
282                                             e instanceof StorageFieldRequiredException) {
283    
284                                    SessionErrors.add(actionRequest, e.getClass());
285                            }
286                            else if (e instanceof AssetCategoryException ||
287                                             e instanceof AssetTagException ||
288                                             e instanceof LocaleException) {
289    
290                                    SessionErrors.add(actionRequest, e.getClass(), e);
291                            }
292                            else {
293                                    throw e;
294                            }
295                    }
296            }
297    
298            @Override
299            public ActionForward render(
300                            ActionMapping actionMapping, ActionForm actionForm,
301                            PortletConfig portletConfig, RenderRequest renderRequest,
302                            RenderResponse renderResponse)
303                    throws Exception {
304    
305                    try {
306                            ActionUtil.getArticle(renderRequest);
307                    }
308                    catch (NoSuchArticleException nsae) {
309    
310                            // Let this slide because the user can manually input a article id
311                            // for a new article that does not yet exist.
312    
313                    }
314                    catch (Exception e) {
315                            if (//e instanceof NoSuchArticleException ||
316                                    e instanceof PrincipalException) {
317    
318                                    SessionErrors.add(renderRequest, e.getClass());
319    
320                                    return actionMapping.findForward("portlet.journal.error");
321                            }
322                            else {
323                                    throw e;
324                            }
325                    }
326    
327                    return actionMapping.findForward(
328                            getForward(renderRequest, "portlet.journal.edit_article"));
329            }
330    
331            protected void deleteArticles(
332                            ActionRequest actionRequest, boolean moveToTrash)
333                    throws Exception {
334    
335                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
336                            WebKeys.THEME_DISPLAY);
337    
338                    String[] deleteArticleIds = null;
339    
340                    String articleId = ParamUtil.getString(actionRequest, "articleId");
341    
342                    if (Validator.isNotNull(articleId)) {
343                            deleteArticleIds = new String[] {articleId};
344                    }
345                    else {
346                            deleteArticleIds = StringUtil.split(
347                                    ParamUtil.getString(actionRequest, "articleIds"));
348                    }
349    
350                    List<TrashedModel> trashedModels = new ArrayList<TrashedModel>();
351    
352                    for (String deleteArticleId : deleteArticleIds) {
353                            if (moveToTrash) {
354                                    JournalArticle article =
355                                            JournalArticleServiceUtil.moveArticleToTrash(
356                                                    themeDisplay.getScopeGroupId(),
357                                                    HtmlUtil.unescape(deleteArticleId));
358    
359                                    trashedModels.add(article);
360                            }
361                            else {
362                                    ActionUtil.deleteArticle(
363                                            actionRequest, HtmlUtil.unescape(deleteArticleId));
364                            }
365                    }
366    
367                    if (moveToTrash && !trashedModels.isEmpty()) {
368                            TrashUtil.addTrashSessionMessages(actionRequest, trashedModels);
369    
370                            hideDefaultSuccessMessage(actionRequest);
371                    }
372            }
373    
374            protected void expireArticles(ActionRequest actionRequest)
375                    throws Exception {
376    
377                    String articleId = ParamUtil.getString(actionRequest, "articleId");
378    
379                    if (Validator.isNotNull(articleId)) {
380                            ActionUtil.expireArticle(actionRequest, articleId);
381                    }
382                    else {
383                            String[] expireArticleIds = StringUtil.split(
384                                    ParamUtil.getString(actionRequest, "expireArticleIds"));
385    
386                            for (String expireArticleId : expireArticleIds) {
387                                    ActionUtil.expireArticle(
388                                            actionRequest, HtmlUtil.unescape(expireArticleId));
389                            }
390                    }
391            }
392    
393            protected String getSaveAndContinueRedirect(
394                            PortletConfig portletConfig, ActionRequest actionRequest,
395                            JournalArticle article, String redirect)
396                    throws Exception {
397    
398                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
399                            WebKeys.THEME_DISPLAY);
400    
401                    String referringPortletResource = ParamUtil.getString(
402                            actionRequest, "referringPortletResource");
403    
404                    String languageId = ParamUtil.getString(actionRequest, "languageId");
405    
406                    PortletURLImpl portletURL = new PortletURLImpl(
407                            actionRequest, portletConfig.getPortletName(),
408                            themeDisplay.getPlid(), PortletRequest.RENDER_PHASE);
409    
410                    portletURL.setParameter("struts_action", "/journal/edit_article");
411                    portletURL.setParameter("redirect", redirect, false);
412                    portletURL.setParameter(
413                            "referringPortletResource", referringPortletResource, false);
414                    portletURL.setParameter(
415                            "resourcePrimKey", String.valueOf(article.getResourcePrimKey()),
416                            false);
417                    portletURL.setParameter(
418                            "groupId", String.valueOf(article.getGroupId()), false);
419                    portletURL.setParameter(
420                            "folderId", String.valueOf(article.getFolderId()), false);
421                    portletURL.setParameter("articleId", article.getArticleId(), false);
422                    portletURL.setParameter(
423                            "version", String.valueOf(article.getVersion()), false);
424                    portletURL.setParameter("languageId", languageId, false);
425                    portletURL.setWindowState(actionRequest.getWindowState());
426    
427                    return portletURL.toString();
428            }
429    
430            protected void subscribeStructure(ActionRequest actionRequest)
431                    throws Exception {
432    
433                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
434                            WebKeys.THEME_DISPLAY);
435    
436                    long ddmStructureId = ParamUtil.getLong(
437                            actionRequest, "ddmStructureId");
438    
439                    JournalArticleServiceUtil.subscribeStructure(
440                            themeDisplay.getScopeGroupId(), themeDisplay.getUserId(),
441                            ddmStructureId);
442            }
443    
444            protected void unsubscribeStructure(ActionRequest actionRequest)
445                    throws Exception {
446    
447                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
448                            WebKeys.THEME_DISPLAY);
449    
450                    long ddmStructureId = ParamUtil.getLong(
451                            actionRequest, "ddmStructureId");
452    
453                    JournalArticleServiceUtil.unsubscribeStructure(
454                            themeDisplay.getScopeGroupId(), themeDisplay.getUserId(),
455                            ddmStructureId);
456            }
457    
458            protected Object[] updateArticle(ActionRequest actionRequest)
459                    throws Exception {
460    
461                    UploadPortletRequest uploadPortletRequest =
462                            PortalUtil.getUploadPortletRequest(actionRequest);
463    
464                    if (_log.isDebugEnabled()) {
465                            _log.debug(
466                                    "Updating article " +
467                                            MapUtil.toString(uploadPortletRequest.getParameterMap()));
468                    }
469    
470                    String cmd = ParamUtil.getString(uploadPortletRequest, Constants.CMD);
471    
472                    long groupId = ParamUtil.getLong(uploadPortletRequest, "groupId");
473                    long folderId = ParamUtil.getLong(uploadPortletRequest, "folderId");
474                    long classNameId = ParamUtil.getLong(
475                            uploadPortletRequest, "classNameId");
476                    long classPK = ParamUtil.getLong(uploadPortletRequest, "classPK");
477    
478                    String articleId = ParamUtil.getString(
479                            uploadPortletRequest, "articleId");
480    
481                    boolean autoArticleId = ParamUtil.getBoolean(
482                            uploadPortletRequest, "autoArticleId");
483                    double version = ParamUtil.getDouble(uploadPortletRequest, "version");
484    
485                    String defaultLanguageId = ParamUtil.getString(
486                            uploadPortletRequest, "defaultLanguageId");
487    
488                    Locale defaultLocale = LocaleUtil.fromLanguageId(defaultLanguageId);
489    
490                    String title = ParamUtil.getString(
491                            uploadPortletRequest, "title_" + defaultLanguageId);
492                    String description = ParamUtil.getString(
493                            uploadPortletRequest, "description_" + defaultLanguageId);
494    
495                    ServiceContext serviceContext = ServiceContextFactory.getInstance(
496                            JournalArticle.class.getName(), uploadPortletRequest);
497    
498                    String structureId = ParamUtil.getString(
499                            uploadPortletRequest, "structureId");
500    
501                    DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getStructure(
502                            PortalUtil.getSiteGroupId(groupId),
503                            PortalUtil.getClassNameId(JournalArticle.class), structureId, true);
504    
505                    String languageId = defaultLanguageId;
506    
507                    Object[] contentAndImages = ActionUtil.getContentAndImages(
508                            ddmStructure, LocaleUtil.fromLanguageId(languageId),
509                            serviceContext);
510    
511                    String content = (String)contentAndImages[0];
512                    Map<String, byte[]> images =
513                            (HashMap<String, byte[]>)contentAndImages[1];
514    
515                    Boolean fileItemThresholdSizeExceeded =
516                            (Boolean)uploadPortletRequest.getAttribute(
517                                    WebKeys.FILE_ITEM_THRESHOLD_SIZE_EXCEEDED);
518    
519                    if ((fileItemThresholdSizeExceeded != null) &&
520                            fileItemThresholdSizeExceeded.booleanValue()) {
521    
522                            throw new ArticleContentSizeException();
523                    }
524    
525                    String type = ParamUtil.getString(uploadPortletRequest, "type");
526                    String templateId = ParamUtil.getString(
527                            uploadPortletRequest, "templateId");
528                    String layoutUuid = ParamUtil.getString(
529                            uploadPortletRequest, "layoutUuid");
530    
531                    Layout targetLayout = JournalUtil.getArticleLayout(layoutUuid, groupId);
532    
533                    if (targetLayout == null) {
534                            layoutUuid = null;
535                    }
536    
537                    int displayDateMonth = ParamUtil.getInteger(
538                            uploadPortletRequest, "displayDateMonth");
539                    int displayDateDay = ParamUtil.getInteger(
540                            uploadPortletRequest, "displayDateDay");
541                    int displayDateYear = ParamUtil.getInteger(
542                            uploadPortletRequest, "displayDateYear");
543                    int displayDateHour = ParamUtil.getInteger(
544                            uploadPortletRequest, "displayDateHour");
545                    int displayDateMinute = ParamUtil.getInteger(
546                            uploadPortletRequest, "displayDateMinute");
547                    int displayDateAmPm = ParamUtil.getInteger(
548                            uploadPortletRequest, "displayDateAmPm");
549    
550                    if (displayDateAmPm == Calendar.PM) {
551                            displayDateHour += 12;
552                    }
553    
554                    int expirationDateMonth = ParamUtil.getInteger(
555                            uploadPortletRequest, "expirationDateMonth");
556                    int expirationDateDay = ParamUtil.getInteger(
557                            uploadPortletRequest, "expirationDateDay");
558                    int expirationDateYear = ParamUtil.getInteger(
559                            uploadPortletRequest, "expirationDateYear");
560                    int expirationDateHour = ParamUtil.getInteger(
561                            uploadPortletRequest, "expirationDateHour");
562                    int expirationDateMinute = ParamUtil.getInteger(
563                            uploadPortletRequest, "expirationDateMinute");
564                    int expirationDateAmPm = ParamUtil.getInteger(
565                            uploadPortletRequest, "expirationDateAmPm");
566                    boolean neverExpire = ParamUtil.getBoolean(
567                            uploadPortletRequest, "neverExpire");
568    
569                    if (expirationDateAmPm == Calendar.PM) {
570                            expirationDateHour += 12;
571                    }
572    
573                    int reviewDateMonth = ParamUtil.getInteger(
574                            uploadPortletRequest, "reviewDateMonth");
575                    int reviewDateDay = ParamUtil.getInteger(
576                            uploadPortletRequest, "reviewDateDay");
577                    int reviewDateYear = ParamUtil.getInteger(
578                            uploadPortletRequest, "reviewDateYear");
579                    int reviewDateHour = ParamUtil.getInteger(
580                            uploadPortletRequest, "reviewDateHour");
581                    int reviewDateMinute = ParamUtil.getInteger(
582                            uploadPortletRequest, "reviewDateMinute");
583                    int reviewDateAmPm = ParamUtil.getInteger(
584                            uploadPortletRequest, "reviewDateAmPm");
585                    boolean neverReview = ParamUtil.getBoolean(
586                            uploadPortletRequest, "neverReview");
587    
588                    if (reviewDateAmPm == Calendar.PM) {
589                            reviewDateHour += 12;
590                    }
591    
592                    boolean indexable = ParamUtil.getBoolean(
593                            uploadPortletRequest, "indexable");
594    
595                    boolean smallImage = ParamUtil.getBoolean(
596                            uploadPortletRequest, "smallImage");
597                    String smallImageURL = ParamUtil.getString(
598                            uploadPortletRequest, "smallImageURL");
599                    File smallFile = uploadPortletRequest.getFile("smallFile");
600    
601                    String articleURL = ParamUtil.getString(
602                            uploadPortletRequest, "articleURL");
603    
604                    serviceContext.setAttribute("defaultLanguageId", defaultLanguageId);
605    
606                    JournalArticle article = null;
607                    String oldUrlTitle = StringPool.BLANK;
608    
609                    if (cmd.equals(Constants.ADD)) {
610                            Map<Locale, String> titleMap = new HashMap<Locale, String>();
611    
612                            titleMap.put(defaultLocale, title);
613    
614                            Map<Locale, String> descriptionMap = new HashMap<Locale, String>();
615    
616                            descriptionMap.put(defaultLocale, description);
617    
618                            // Add article
619    
620                            article = JournalArticleServiceUtil.addArticle(
621                                    groupId, folderId, classNameId, classPK, articleId,
622                                    autoArticleId, titleMap, descriptionMap, content, type,
623                                    structureId, templateId, layoutUuid, displayDateMonth,
624                                    displayDateDay, displayDateYear, displayDateHour,
625                                    displayDateMinute, expirationDateMonth, expirationDateDay,
626                                    expirationDateYear, expirationDateHour, expirationDateMinute,
627                                    neverExpire, reviewDateMonth, reviewDateDay, reviewDateYear,
628                                    reviewDateHour, reviewDateMinute, neverReview, indexable,
629                                    smallImage, smallImageURL, smallFile, images, articleURL,
630                                    serviceContext);
631    
632                            AssetPublisherUtil.addAndStoreSelection(
633                                    actionRequest, JournalArticle.class.getName(),
634                                    article.getResourcePrimKey(), -1);
635                    }
636                    else {
637    
638                            // Update article
639    
640                            article = JournalArticleServiceUtil.getArticle(
641                                    groupId, articleId, version);
642    
643                            Map<Locale, String> titleMap = article.getTitleMap();
644                            Map<Locale, String> descriptionMap = article.getDescriptionMap();
645    
646                            String tempOldUrlTitle = article.getUrlTitle();
647    
648                            if (cmd.equals(Constants.PREVIEW) || cmd.equals(Constants.UPDATE)) {
649                                    titleMap.put(defaultLocale, title);
650                                    descriptionMap.put(defaultLocale, description);
651    
652                                    article = JournalArticleServiceUtil.updateArticle(
653                                            groupId, folderId, articleId, version, titleMap,
654                                            descriptionMap, content, type, structureId, templateId,
655                                            layoutUuid, displayDateMonth, displayDateDay,
656                                            displayDateYear, displayDateHour, displayDateMinute,
657                                            expirationDateMonth, expirationDateDay, expirationDateYear,
658                                            expirationDateHour, expirationDateMinute, neverExpire,
659                                            reviewDateMonth, reviewDateDay, reviewDateYear,
660                                            reviewDateHour, reviewDateMinute, neverReview, indexable,
661                                            smallImage, smallImageURL, smallFile, images, articleURL,
662                                            serviceContext);
663                            }
664    
665                            if (!tempOldUrlTitle.equals(article.getUrlTitle())) {
666                                    oldUrlTitle = tempOldUrlTitle;
667                            }
668                    }
669    
670                    // Recent articles
671    
672                    JournalUtil.addRecentArticle(actionRequest, article);
673    
674                    // Journal content
675    
676                    PortletPreferences portletPreferences = getStrictPortletSetup(
677                            actionRequest);
678    
679                    if (portletPreferences != null) {
680                            portletPreferences.setValue(
681                                    "groupId", String.valueOf(article.getGroupId()));
682                            portletPreferences.setValue("articleId", article.getArticleId());
683    
684                            portletPreferences.store();
685    
686                            String portletResource = ParamUtil.getString(
687                                    actionRequest, "portletResource");
688    
689                            updateContentSearch(
690                                    actionRequest, portletResource, article.getArticleId());
691                    }
692    
693                    return new Object[] {article, oldUrlTitle};
694            }
695    
696            protected void updateContentSearch(
697                            ActionRequest actionRequest, String portletResource,
698                            String articleId)
699                    throws Exception {
700    
701                    ThemeDisplay themeDisplay = (ThemeDisplay)actionRequest.getAttribute(
702                            WebKeys.THEME_DISPLAY);
703    
704                    Layout layout = themeDisplay.getLayout();
705    
706                    JournalContentSearchLocalServiceUtil.updateContentSearch(
707                            layout.getGroupId(), layout.isPrivateLayout(), layout.getLayoutId(),
708                            portletResource, articleId, true);
709            }
710    
711            private static Log _log = LogFactoryUtil.getLog(EditArticleAction.class);
712    
713    }