001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.social.util;
016    
017    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
018    import com.liferay.portal.kernel.log.Log;
019    import com.liferay.portal.kernel.log.LogFactoryUtil;
020    import com.liferay.portal.kernel.util.GetterUtil;
021    import com.liferay.portal.kernel.util.ListUtil;
022    import com.liferay.portal.kernel.util.ProxyFactory;
023    import com.liferay.portal.kernel.util.Tuple;
024    import com.liferay.portal.kernel.util.Validator;
025    import com.liferay.portal.kernel.xml.Document;
026    import com.liferay.portal.kernel.xml.Element;
027    import com.liferay.portal.kernel.xml.SAXReaderUtil;
028    import com.liferay.portal.util.JavaFieldsParser;
029    import com.liferay.portlet.social.model.SocialAchievement;
030    import com.liferay.portlet.social.model.SocialActivityCounterConstants;
031    import com.liferay.portlet.social.model.SocialActivityCounterDefinition;
032    import com.liferay.portlet.social.model.SocialActivityDefinition;
033    import com.liferay.portlet.social.model.SocialActivityProcessor;
034    
035    import java.util.ArrayList;
036    import java.util.Collection;
037    import java.util.Collections;
038    import java.util.HashMap;
039    import java.util.HashSet;
040    import java.util.List;
041    import java.util.Map;
042    import java.util.Set;
043    
044    /**
045     * @author Zsolt Berentey
046     */
047    public class SocialConfigurationUtil {
048    
049            public static Collection<String> getActivityCounterNames() {
050                    return getActivityCounterNames(SocialActivityCounterConstants.TYPE_ALL);
051            }
052    
053            public static Collection<String> getActivityCounterNames(int ownerType) {
054                    Set<String> activityCounterNames = new HashSet<String>();
055    
056                    for (Map<Integer, SocialActivityDefinition> activityDefinitions :
057                                    _activityDefinitions.values()) {
058    
059                            for (SocialActivityDefinition activityDefinition :
060                                            activityDefinitions.values()) {
061    
062                                    for (SocialActivityCounterDefinition activityCounterDefinition :
063                                                    activityDefinition.getActivityCounterDefinitions()) {
064    
065                                            if ((ownerType ==
066                                                            SocialActivityCounterConstants.TYPE_ALL) ||
067                                                    (ownerType ==
068                                                            activityCounterDefinition.getOwnerType())) {
069    
070                                                    activityCounterNames.add(
071                                                            activityCounterDefinition.getName());
072                                            }
073                                    }
074                            }
075                    }
076    
077                    return activityCounterNames;
078            }
079    
080            public static SocialActivityDefinition getActivityDefinition(
081                    String modelName, int activityType) {
082    
083                    Map<Integer, SocialActivityDefinition> activityDefinitions =
084                            _activityDefinitions.get(modelName);
085    
086                    if (activityDefinitions == null) {
087                            return null;
088                    }
089    
090                    return activityDefinitions.get(activityType);
091            }
092    
093            public static List<SocialActivityDefinition> getActivityDefinitions(
094                    String modelName) {
095    
096                    Map<Integer, SocialActivityDefinition> activityDefinitions =
097                            _activityDefinitions.get(modelName);
098    
099                    if (activityDefinitions == null) {
100                            return Collections.emptyList();
101                    }
102    
103                    return ListUtil.fromCollection(activityDefinitions.values());
104            }
105    
106            public static String[] getActivityModelNames() {
107                    Set<String> activityModelNames = _activityDefinitions.keySet();
108    
109                    return activityModelNames.toArray(
110                            new String[activityModelNames.size()]);
111            }
112    
113            public static List<Object> read(ClassLoader classLoader, String[] xmls)
114                    throws Exception {
115    
116                    List<Object> objects = new ArrayList<Object>();
117    
118                    for (String xml : xmls) {
119                            _read(classLoader, xml, objects);
120                    }
121    
122                    return objects;
123            }
124    
125            public static void removeActivityDefinition(
126                    SocialActivityDefinition activityDefinition) {
127    
128                    Map<Integer, SocialActivityDefinition> activityDefinitions =
129                            _activityDefinitions.get(activityDefinition.getModelName());
130    
131                    if (activityDefinitions != null) {
132                            activityDefinitions.remove(activityDefinition.getActivityType());
133                    }
134            }
135    
136            private static void _read(
137                            ClassLoader classLoader, String xml, List<Object> objects)
138                    throws Exception {
139    
140                    if (xml == null) {
141                            return;
142                    }
143    
144                    xml = JavaFieldsParser.parse(classLoader, xml);
145    
146                    Document document = SAXReaderUtil.read(xml);
147    
148                    Element rootElement = document.getRootElement();
149    
150                    List<Element> activityElements = rootElement.elements("activity");
151    
152                    for (Element activityElement : activityElements) {
153                            _readActivity(classLoader, objects, activityElement);
154                    }
155            }
156    
157            private static void _readAchievement(
158                            ClassLoader classLoader, List<Object> objects,
159                            SocialActivityDefinition activityDefinition,
160                            Element achievementElement)
161                    throws Exception {
162    
163                    String achievementClassName = GetterUtil.getString(
164                            achievementElement.elementText("achievement-class"));
165    
166                    SocialAchievement achievement =
167                            (SocialAchievement)ProxyFactory.newInstance(
168                                    classLoader, SocialAchievement.class, achievementClassName);
169    
170                    String name = GetterUtil.getString(
171                            achievementElement.elementText("name"));
172    
173                    achievement.setName(name);
174    
175                    String icon = GetterUtil.getString(
176                            achievementElement.elementText("icon"));
177    
178                    achievement.setIcon(icon);
179    
180                    List<Element> propertyElements = achievementElement.elements(
181                            "property");
182    
183                    for (Element propertyElement : propertyElements) {
184                            _readAchievementProperty(achievement, propertyElement);
185                    }
186    
187                    List<SocialAchievement> achievements =
188                            activityDefinition.getAchievements();
189    
190                    achievements.add(achievement);
191    
192                    Tuple tuple = new Tuple(activityDefinition, achievement);
193    
194                    objects.add(tuple);
195            }
196    
197            private static void _readAchievementProperty(
198                    SocialAchievement achievement, Element propertyElement) {
199    
200                    String name = GetterUtil.getString(
201                            propertyElement.elementText("name"));
202                    String value = GetterUtil.getString(
203                            propertyElement.elementText("value"));
204    
205                    BeanPropertiesUtil.setProperty(achievement, name, value);
206            }
207    
208            private static void _readActivity(
209                            ClassLoader classLoader, Element activityElement,
210                            SocialActivityDefinition activityDefinition)
211                    throws Exception {
212    
213                    String languageKey = GetterUtil.getString(
214                            activityElement.elementText("language-key"));
215    
216                    activityDefinition.setLanguageKey(languageKey);
217    
218                    boolean logActivity = GetterUtil.getBoolean(
219                            activityElement.elementText("log-activity"));
220    
221                    activityDefinition.setLogActivity(logActivity);
222    
223                    String processorClassName = GetterUtil.getString(
224                            activityElement.elementText("processor-class"));
225    
226                    if (Validator.isNotNull(processorClassName)) {
227                            SocialActivityProcessor activityProcessor =
228                                    (SocialActivityProcessor)ProxyFactory.newInstance(
229                                            classLoader, SocialActivityProcessor.class,
230                                            processorClassName);
231    
232                            activityDefinition.setActivityProcessor(activityProcessor);
233                    }
234    
235                    _readActivityContribution(activityElement, activityDefinition);
236                    _readActivityParticipation(activityElement, activityDefinition);
237            }
238    
239            private static void _readActivity(
240                            ClassLoader classLoader, List<Object> objects,
241                            Element activityElement)
242                    throws Exception {
243    
244                    String modelName = GetterUtil.getString(
245                            activityElement.elementText("model-name"));
246    
247                    Map<Integer, SocialActivityDefinition> activityDefinitions =
248                            _activityDefinitions.get(modelName);
249    
250                    if (activityDefinitions == null) {
251                            activityDefinitions =
252                                    new HashMap<Integer, SocialActivityDefinition>();
253    
254                            _activityDefinitions.put(modelName, activityDefinitions);
255                    }
256    
257                    int activityType = GetterUtil.getInteger(
258                            activityElement.elementText("activity-type"));
259    
260                    SocialActivityDefinition activityDefinition = activityDefinitions.get(
261                            activityType);
262    
263                    if (activityDefinition == null) {
264                            activityDefinition = new SocialActivityDefinition();
265    
266                            activityDefinition.setModelName(modelName);
267                            activityDefinition.setActivityType(activityType);
268    
269                            _readActivity(classLoader, activityElement, activityDefinition);
270    
271                            activityDefinitions.put(activityType, activityDefinition);
272    
273                            objects.add(activityDefinition);
274                    }
275    
276                    List<Element> counterElements = activityElement.elements("counter");
277    
278                    for (Element counterElement : counterElements) {
279                            _readCounter(objects, activityDefinition, counterElement);
280                    }
281    
282                    List<Element> achievementElements = activityElement.elements(
283                            "achievement");
284    
285                    for (Element achievementElement : achievementElements) {
286                            _readAchievement(
287                                    classLoader, objects, activityDefinition, achievementElement);
288                    }
289            }
290    
291            private static void _readActivityContribution(
292                    Element activityElement, SocialActivityDefinition activityDefinition) {
293    
294                    Element contributionValueElement = activityElement.element(
295                            "contribution-value");
296    
297                    if (contributionValueElement == null) {
298                            return;
299                    }
300    
301                    SocialActivityCounterDefinition contributionActivityCounterDefinition =
302                            new SocialActivityCounterDefinition();
303    
304                    contributionActivityCounterDefinition.setName(
305                            SocialActivityCounterConstants.NAME_CONTRIBUTION);
306                    contributionActivityCounterDefinition.setOwnerType(
307                            SocialActivityCounterConstants.TYPE_CREATOR);
308    
309                    int increment = GetterUtil.getInteger(
310                            contributionValueElement.getText());
311    
312                    contributionActivityCounterDefinition.setIncrement(increment);
313    
314                    Element contributionLimitElement = activityElement.element(
315                            "contribution-limit");
316    
317                    if (contributionLimitElement != null) {
318                            String limitPeriod = contributionLimitElement.attributeValue(
319                                    "period");
320    
321                            contributionActivityCounterDefinition.setLimitPeriod(limitPeriod);
322    
323                            int limitValue = GetterUtil.getInteger(
324                                    contributionLimitElement.getText());
325    
326                            contributionActivityCounterDefinition.setLimitValue(limitValue);
327                    }
328    
329                    activityDefinition.addCounter(contributionActivityCounterDefinition);
330    
331                    SocialActivityCounterDefinition popularityActivityCounterDefinition =
332                            new SocialActivityCounterDefinition();
333    
334                    popularityActivityCounterDefinition.setName(
335                            SocialActivityCounterConstants.NAME_POPULARITY);
336                    popularityActivityCounterDefinition.setOwnerType(
337                            SocialActivityCounterConstants.TYPE_ASSET);
338                    popularityActivityCounterDefinition.setIncrement(
339                            contributionActivityCounterDefinition.getIncrement());
340                    popularityActivityCounterDefinition.setLimitPeriod(
341                            contributionActivityCounterDefinition.getLimitPeriod());
342                    popularityActivityCounterDefinition.setLimitValue(
343                            contributionActivityCounterDefinition.getLimitValue());
344    
345                    activityDefinition.addCounter(popularityActivityCounterDefinition);
346            }
347    
348            private static void _readActivityParticipation(
349                    Element activityElement, SocialActivityDefinition activityDefinition) {
350    
351                    Element participationValueElement = activityElement.element(
352                            "participation-value");
353    
354                    if (participationValueElement == null) {
355                            return;
356                    }
357    
358                    SocialActivityCounterDefinition activityCounterDefinition =
359                            new SocialActivityCounterDefinition();
360    
361                    activityCounterDefinition.setName(
362                            SocialActivityCounterConstants.NAME_PARTICIPATION);
363                    activityCounterDefinition.setOwnerType(
364                            SocialActivityCounterConstants.TYPE_ACTOR);
365    
366                    int increment = GetterUtil.getInteger(
367                            participationValueElement.getText());
368    
369                    activityCounterDefinition.setIncrement(increment);
370    
371                    Element participationLimitElement = activityElement.element(
372                            "participation-limit");
373    
374                    if (participationLimitElement != null) {
375                            String limitPeriod = participationLimitElement.attributeValue(
376                                    "period");
377    
378                            activityCounterDefinition.setLimitPeriod(limitPeriod);
379    
380                            int limitValue = GetterUtil.getInteger(
381                                    participationLimitElement.getText());
382    
383                            activityCounterDefinition.setLimitValue(limitValue);
384                    }
385    
386                    activityDefinition.addCounter(activityCounterDefinition);
387            }
388    
389            private static void _readCounter(
390                    List<Object> objects, SocialActivityDefinition activityDefinition,
391                    Element counterElement) {
392    
393                    SocialActivityCounterDefinition activityCounterDefinition =
394                            new SocialActivityCounterDefinition();
395    
396                    int increment = GetterUtil.getInteger(
397                            counterElement.elementText("increment"), 1);
398    
399                    activityCounterDefinition.setIncrement(increment);
400    
401                    boolean enabled = GetterUtil.getBoolean(
402                            counterElement.elementText("enabled"), true);
403    
404                    activityCounterDefinition.setEnabled(enabled);
405    
406                    String name = GetterUtil.getString(counterElement.elementText("name"));
407    
408                    activityCounterDefinition.setName(name);
409    
410                    String ownerType = GetterUtil.getString(
411                            counterElement.elementText("owner-type"));
412    
413                    activityCounterDefinition.setOwnerType(ownerType);
414    
415                    if (activityCounterDefinition.getOwnerType() == 0) {
416                            if (_log.isWarnEnabled()) {
417                                    _log.warn(
418                                            "Invalid owner type " + ownerType + " for  model " +
419                                                    activityDefinition.getModelName());
420                            }
421    
422                            return;
423                    }
424    
425                    activityDefinition.addCounter(activityCounterDefinition);
426    
427                    Tuple tuple = new Tuple(activityDefinition, activityCounterDefinition);
428    
429                    objects.add(tuple);
430            }
431    
432            private static Log _log = LogFactoryUtil.getLog(
433                    SocialConfigurationUtil.class);
434    
435            private static Map<String, Map<Integer, SocialActivityDefinition>>
436                    _activityDefinitions =
437                            new HashMap<String, Map<Integer, SocialActivityDefinition>>();
438    
439    }