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.portal.kernel.backgroundtask.display;
016    
017    import com.liferay.portal.kernel.backgroundtask.BackgroundTask;
018    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskStatus;
019    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskStatusRegistryUtil;
020    import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
021    import com.liferay.portal.kernel.json.JSONArray;
022    import com.liferay.portal.kernel.json.JSONException;
023    import com.liferay.portal.kernel.json.JSONFactoryUtil;
024    import com.liferay.portal.kernel.json.JSONObject;
025    import com.liferay.portal.kernel.language.LanguageUtil;
026    import com.liferay.portal.kernel.log.Log;
027    import com.liferay.portal.kernel.log.LogFactoryUtil;
028    import com.liferay.portal.kernel.template.Template;
029    import com.liferay.portal.kernel.template.TemplateConstants;
030    import com.liferay.portal.kernel.template.TemplateException;
031    import com.liferay.portal.kernel.template.TemplateManager;
032    import com.liferay.portal.kernel.template.TemplateManagerUtil;
033    import com.liferay.portal.kernel.template.TemplateResource;
034    import com.liferay.portal.kernel.util.GetterUtil;
035    import com.liferay.portal.kernel.util.StringPool;
036    
037    import java.io.Writer;
038    
039    import java.util.Iterator;
040    import java.util.Locale;
041    import java.util.Map;
042    
043    /**
044     * @author Andrew Betts
045     */
046    public abstract class BaseBackgroundTaskDisplay
047            implements BackgroundTaskDisplay {
048    
049            public BaseBackgroundTaskDisplay(BackgroundTask backgroundTask) {
050                    this.backgroundTask = backgroundTask;
051    
052                    backgroundTaskStatus =
053                            BackgroundTaskStatusRegistryUtil.getBackgroundTaskStatus(
054                                    backgroundTask.getBackgroundTaskId());
055            }
056    
057            @Override
058            public abstract int getPercentage();
059    
060            @Override
061            public int getStatus() {
062                    return backgroundTask.getStatus();
063            }
064    
065            @Override
066            public String getStatusLabel() {
067                    return getStatusLabel(Locale.getDefault());
068            }
069    
070            @Override
071            public String getStatusLabel(Locale locale) {
072                    return LanguageUtil.get(locale, backgroundTask.getStatusLabel());
073            }
074    
075            @Override
076            public boolean hasPercentage() {
077                    if (getPercentage() >= PERCENTAGE_MIN) {
078                            return true;
079                    }
080    
081                    return false;
082            }
083    
084            @Override
085            public String renderDisplayTemplate() {
086                    return renderDisplayTemplate(Locale.getDefault());
087            }
088    
089            @Override
090            public String renderDisplayTemplate(Locale locale) {
091                    TemplateResource templateResource = getTemplateResource();
092    
093                    if (templateResource == null) {
094                            return StringPool.BLANK;
095                    }
096    
097                    TemplateManager templateManager =
098                            TemplateManagerUtil.getTemplateManager(
099                                    TemplateConstants.LANG_TYPE_FTL);
100    
101                    Template template = templateManager.getTemplate(templateResource, true);
102    
103                    template.put("backgroundTask", backgroundTask);
104                    template.put("backgroundTaskDisplay", this);
105                    template.put("backgroundTaskStatus", backgroundTaskStatus);
106                    template.put(
107                            "statusMessageJSONObject", getStatusMessageJSONObject(locale));
108    
109                    Map<String, Object> templateVars = getTemplateVars();
110    
111                    if (templateVars != null) {
112                            template.putAll(getTemplateVars());
113                    }
114    
115                    Writer writer = new UnsyncStringWriter();
116    
117                    try {
118                            template.processTemplate(writer);
119                    }
120                    catch (TemplateException te) {
121                            if (_log.isDebugEnabled()) {
122                                    _log.debug(te, te);
123                            }
124    
125                            return StringPool.BLANK;
126                    }
127    
128                    return writer.toString();
129            }
130    
131            protected long getBackgroundTaskStatusAttributeLong(String attributeKey) {
132                    return GetterUtil.getLong(
133                            backgroundTaskStatus.getAttribute(attributeKey));
134            }
135    
136            protected String getBackgroundTaskStatusAttributeString(
137                    String attributeKey) {
138    
139                    return GetterUtil.getString(
140                            backgroundTaskStatus.getAttribute(attributeKey));
141            }
142    
143            protected JSONObject getStatusMessageJSONObject(Locale locale) {
144                    JSONObject jsonObject = null;
145    
146                    try {
147                            jsonObject = JSONFactoryUtil.createJSONObject(
148                                    backgroundTask.getStatusMessage());
149                    }
150                    catch (JSONException jsone) {
151                            if (_log.isDebugEnabled()) {
152                                    _log.debug(jsone, jsone);
153                            }
154                    }
155    
156                    return translateJSON(jsonObject, locale);
157            }
158    
159            protected abstract TemplateResource getTemplateResource();
160    
161            protected abstract Map<String, Object> getTemplateVars();
162    
163            protected boolean hasBackgroundTaskStatus() {
164                    if (backgroundTaskStatus != null) {
165                            return true;
166                    }
167    
168                    return false;
169            }
170    
171            protected JSONArray translateJSON(JSONArray jsonArray, Locale locale) {
172                    JSONArray translatedJSON = JSONFactoryUtil.createJSONArray();
173    
174                    for (Object object : jsonArray) {
175                            if (object instanceof JSONObject) {
176                                    translatedJSON.put(translateJSON((JSONObject)object, locale));
177                            }
178                            else if (object instanceof JSONArray) {
179                                    translatedJSON.put(translateJSON((JSONArray)object, locale));
180                            }
181                            else if (object instanceof String) {
182                                    translatedJSON.put(LanguageUtil.get(locale, (String)object));
183                            }
184                            else {
185                                    translatedJSON.put(object);
186                            }
187                    }
188    
189                    return translatedJSON;
190            }
191    
192            protected JSONObject translateJSON(JSONObject jsonObject, Locale locale) {
193                    if (locale == null) {
194                            return jsonObject;
195                    }
196    
197                    JSONObject translatedJSON = JSONFactoryUtil.createJSONObject();
198    
199                    Iterator<String> iterator = jsonObject.keys();
200    
201                    while (iterator.hasNext()) {
202                            String key = iterator.next();
203    
204                            Object object = jsonObject.get(key);
205    
206                            if (object instanceof JSONObject) {
207                                    translatedJSON.put(
208                                            key, translateJSON((JSONObject)object, locale));
209                            }
210                            else if (object instanceof JSONArray) {
211                                    translatedJSON.put(
212                                            key, translateJSON((JSONArray)object, locale));
213                            }
214                            else if (object instanceof String) {
215                                    translatedJSON.put(
216                                            key, LanguageUtil.get(locale, (String)object));
217                            }
218                            else {
219                                    translatedJSON.put(key, object);
220                            }
221                    }
222    
223                    return translatedJSON;
224            }
225    
226            protected static final int PERCENTAGE_MAX = 100;
227    
228            protected static final int PERCENTAGE_MIN = 0;
229    
230            protected static final int PERCENTAGE_NONE = -1;
231    
232            protected final BackgroundTask backgroundTask;
233            protected final BackgroundTaskStatus backgroundTaskStatus;
234    
235            private static final Log _log = LogFactoryUtil.getLog(
236                    BaseBackgroundTaskDisplay.class);
237    
238    }