001    /**
002     * Copyright (c) 2000-2012 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.service.impl;
016    
017    import com.liferay.portal.kernel.dao.db.DB;
018    import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
019    import com.liferay.portal.kernel.dao.orm.QueryUtil;
020    import com.liferay.portal.kernel.exception.PortalException;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.log.Log;
023    import com.liferay.portal.kernel.log.LogFactoryUtil;
024    import com.liferay.portal.kernel.transaction.Propagation;
025    import com.liferay.portal.kernel.transaction.Transactional;
026    import com.liferay.portal.kernel.util.PropsKeys;
027    import com.liferay.portal.kernel.util.StringBundler;
028    import com.liferay.portal.kernel.util.StringPool;
029    import com.liferay.portal.kernel.util.StringUtil;
030    import com.liferay.portal.kernel.util.Tuple;
031    import com.liferay.portal.model.Group;
032    import com.liferay.portal.model.Lock;
033    import com.liferay.portal.model.User;
034    import com.liferay.portal.util.PortalUtil;
035    import com.liferay.portal.util.PropsValues;
036    import com.liferay.portlet.asset.model.AssetEntry;
037    import com.liferay.portlet.social.model.SocialAchievement;
038    import com.liferay.portlet.social.model.SocialActivity;
039    import com.liferay.portlet.social.model.SocialActivityCounter;
040    import com.liferay.portlet.social.model.SocialActivityCounterConstants;
041    import com.liferay.portlet.social.model.SocialActivityCounterDefinition;
042    import com.liferay.portlet.social.model.SocialActivityDefinition;
043    import com.liferay.portlet.social.model.SocialActivityLimit;
044    import com.liferay.portlet.social.model.SocialActivityProcessor;
045    import com.liferay.portlet.social.service.SocialActivityCounterLocalService;
046    import com.liferay.portlet.social.service.base.SocialActivityCounterLocalServiceBaseImpl;
047    import com.liferay.portlet.social.service.persistence.SocialActivityCounterFinderUtil;
048    import com.liferay.portlet.social.util.SocialCounterPeriodUtil;
049    
050    import java.util.Arrays;
051    import java.util.Collections;
052    import java.util.Date;
053    import java.util.HashMap;
054    import java.util.List;
055    import java.util.Map;
056    
057    /**
058     * @author Zsolt Berentey
059     * @author Shuyang Zhou
060     */
061    public class SocialActivityCounterLocalServiceImpl
062            extends SocialActivityCounterLocalServiceBaseImpl {
063    
064            public SocialActivityCounter addActivityCounter(
065                            long groupId, long classNameId, long classPK, String name,
066                            int ownerType, int currentValue, int totalValue, int startPeriod,
067                            int endPeriod)
068                    throws PortalException, SystemException {
069    
070                    return addActivityCounter(
071                            groupId, classNameId, classPK, name, ownerType, currentValue,
072                            totalValue, startPeriod, endPeriod, 0, 0);
073            }
074    
075            public SocialActivityCounter addActivityCounter(
076                            long groupId, long classNameId, long classPK, String name,
077                            int ownerType, int currentValue, int totalValue, int startPeriod,
078                            int endPeriod, long previousActivityCounterId, int periodLength)
079                    throws PortalException, SystemException {
080    
081                    SocialActivityCounter activityCounter = null;
082    
083                    String lockKey = getLockKey(
084                            groupId, classNameId, classPK, name, ownerType);
085    
086                    Lock lock = null;
087    
088                    while (true) {
089                            try {
090                                    lock = lockLocalService.lock(
091                                            SocialActivityCounter.class.getName(), lockKey, lockKey,
092                                            false);
093                            }
094                            catch (Exception e) {
095                                    if (_log.isWarnEnabled()) {
096                                            _log.warn(
097                                                    "Unable to acquire activity counter lock. Retrying.");
098                                    }
099    
100                                    continue;
101                            }
102    
103                            if (lock.isNew()) {
104                                    try {
105                                            DB db = DBFactoryUtil.getDB();
106    
107                                            String dbType = db.getType();
108    
109                                            if (dbType.equals(DB.TYPE_HYPERSONIC)) {
110    
111                                                    // LPS-25408
112    
113                                                    activityCounter = createActivityCounter(
114                                                            groupId, classNameId, classPK, name, ownerType,
115                                                            currentValue, totalValue, startPeriod, endPeriod,
116                                                            previousActivityCounterId, periodLength);
117                                            }
118                                            else {
119                                                    activityCounter =
120                                                            socialActivityCounterLocalService.
121                                                                    createActivityCounter(
122                                                                            groupId, classNameId, classPK, name,
123                                                                            ownerType, currentValue, totalValue,
124                                                                            startPeriod, endPeriod,
125                                                                            previousActivityCounterId, periodLength);
126    
127                                            }
128                                    }
129                                    finally {
130                                            lockLocalService.unlock(
131                                                    SocialActivityCounter.class.getName(), lockKey, lockKey,
132                                                    false);
133                                    }
134    
135                                    break;
136                            }
137    
138                            Date createDate = lock.getCreateDate();
139    
140                            if ((System.currentTimeMillis() - createDate.getTime()) >=
141                                            PropsValues.SOCIAL_ACTIVITY_COUNTER_LOCK_TIMEOUT) {
142    
143                                    lockLocalService.unlock(
144                                            SocialActivityCounter.class.getName(), lockKey,
145                                            lock.getOwner(), false);
146    
147                                    if (_log.isWarnEnabled()) {
148                                            _log.warn(
149                                                    "Forcibly removed lock " + lock + ". See " +
150                                                            PropsKeys.SOCIAL_ACTIVITY_COUNTER_LOCK_TIMEOUT);
151                                    }
152                            }
153                            else {
154                                    try {
155                                            Thread.sleep(
156                                                    PropsValues.SOCIAL_ACTIVITY_COUNTER_LOCK_RETRY_DELAY);
157                                    }
158                                    catch (InterruptedException ie) {
159                                            if (_log.isWarnEnabled()) {
160                                                    _log.warn(
161                                                            "Interrupted while waiting to reacquire lock", ie);
162                                            }
163                                    }
164                            }
165                    }
166    
167                    return activityCounter;
168            }
169    
170            public void addActivityCounters(SocialActivity activity)
171                    throws PortalException, SystemException {
172    
173                    if (!socialActivitySettingLocalService.isEnabled(
174                                    activity.getGroupId(), activity.getClassNameId())) {
175    
176                            return;
177                    }
178    
179                    User user = userPersistence.findByPrimaryKey(activity.getUserId());
180    
181                    SocialActivityDefinition activityDefinition =
182                            socialActivitySettingLocalService.getActivityDefinition(
183                                    activity.getGroupId(), activity.getClassName(),
184                                    activity.getType());
185    
186                    if ((activityDefinition == null) || !activityDefinition.isEnabled()) {
187                            return;
188                    }
189    
190                    SocialActivityProcessor activityProcessor =
191                            activityDefinition.getActivityProcessor();
192    
193                    if (activityProcessor != null) {
194                            activityProcessor.processActivity(activity);
195                    }
196    
197                    AssetEntry assetEntry = activity.getAssetEntry();
198    
199                    User assetEntryUser = userPersistence.findByPrimaryKey(
200                            assetEntry.getUserId());
201    
202                    for (SocialActivityCounterDefinition activityCounterDefinition :
203                                    activityDefinition.getActivityCounterDefinitions()) {
204    
205                            if (addActivityCounter(
206                                            user, assetEntryUser, activityCounterDefinition) &&
207                                    checkActivityLimit(user, activity, activityCounterDefinition)) {
208    
209                                    incrementActivityCounter(
210                                            activity.getGroupId(), user, activity.getAssetEntry(),
211                                            activityCounterDefinition);
212                            }
213                    }
214    
215                    for (SocialAchievement achievement :
216                                    activityDefinition.getAchievements()) {
217    
218                            achievement.processActivity(activity);
219                    }
220    
221                    if (!user.isDefaultUser() && user.isActive()) {
222                            incrementActivityCounter(
223                                    activity.getGroupId(),
224                                    PortalUtil.getClassNameId(User.class.getName()),
225                                    activity.getUserId(),
226                                    SocialActivityCounterConstants.NAME_USER_ACTIVITIES,
227                                    SocialActivityCounterConstants.TYPE_ACTOR, 1,
228                                    SocialActivityCounterConstants.PERIOD_LENGTH_SYSTEM);
229                    }
230    
231                    if (!assetEntryUser.isDefaultUser() && assetEntryUser.isActive()) {
232                            incrementActivityCounter(
233                                    activity.getGroupId(), activity.getClassNameId(),
234                                    activity.getClassPK(),
235                                    SocialActivityCounterConstants.NAME_ASSET_ACTIVITIES,
236                                    SocialActivityCounterConstants.TYPE_ASSET, 1,
237                                    SocialActivityCounterConstants.PERIOD_LENGTH_SYSTEM);
238                    }
239            }
240    
241            /**
242             * @deprecated {@link #createActivityCounter(long, long, long, String, int,
243             *             int, int, int, int, long, int)}
244             */
245            @Transactional(propagation = Propagation.REQUIRES_NEW)
246            public SocialActivityCounter createActivityCounter(
247                            long groupId, long classNameId, long classPK, String name,
248                            int ownerType, int currentValue, int totalValue, int startPeriod,
249                            int endPeriod)
250                    throws PortalException, SystemException {
251    
252                    return createActivityCounter(
253                            groupId, classNameId, classPK, name, ownerType, currentValue,
254                            totalValue, startPeriod, endPeriod, 0, 0);
255            }
256    
257            @Transactional(propagation = Propagation.REQUIRES_NEW)
258            public SocialActivityCounter createActivityCounter(
259                            long groupId, long classNameId, long classPK, String name,
260                            int ownerType, int currentValue, int totalValue, int startPeriod,
261                            int endPeriod, long previousActivityCounterId, int periodLength)
262                    throws PortalException, SystemException {
263    
264                    SocialActivityCounter activityCounter = null;
265    
266                    if (previousActivityCounterId != 0) {
267                            activityCounter = socialActivityCounterPersistence.findByPrimaryKey(
268                                    previousActivityCounterId);
269    
270                            if (periodLength ==
271                                            SocialActivityCounterConstants.PERIOD_LENGTH_SYSTEM) {
272    
273                                    activityCounter.setEndPeriod(
274                                            SocialCounterPeriodUtil.getStartPeriod() - 1);
275                            }
276                            else {
277                                    activityCounter.setEndPeriod(
278                                            activityCounter.getStartPeriod() + periodLength - 1);
279                            }
280    
281                            socialActivityCounterPersistence.update(activityCounter, false);
282                    }
283    
284                    activityCounter = socialActivityCounterPersistence.fetchByG_C_C_N_O_E(
285                            groupId, classNameId, classPK, name, ownerType, endPeriod, false);
286    
287                    if (activityCounter != null) {
288                            return activityCounter;
289                    }
290    
291                    Group group = groupPersistence.findByPrimaryKey(groupId);
292    
293                    long activityCounterId = counterLocalService.increment();
294    
295                    activityCounter = socialActivityCounterPersistence.create(
296                            activityCounterId);
297    
298                    activityCounter.setGroupId(groupId);
299                    activityCounter.setCompanyId(group.getCompanyId());
300                    activityCounter.setClassNameId(classNameId);
301                    activityCounter.setClassPK(classPK);
302                    activityCounter.setName(name);
303                    activityCounter.setOwnerType(ownerType);
304                    activityCounter.setCurrentValue(currentValue);
305                    activityCounter.setTotalValue(totalValue);
306                    activityCounter.setStartPeriod(startPeriod);
307                    activityCounter.setEndPeriod(endPeriod);
308    
309                    socialActivityCounterPersistence.update(activityCounter, false);
310    
311                    return activityCounter;
312            }
313    
314            public void deleteActivityCounters(AssetEntry assetEntry)
315                    throws PortalException, SystemException {
316    
317                    if (assetEntry == null) {
318                            return;
319                    }
320    
321                    SocialActivityCounter latestContributionActivityCounter =
322                            fetchLatestActivityCounter(
323                                    assetEntry.getGroupId(),
324                                    PortalUtil.getClassNameId(User.class.getName()),
325                                    assetEntry.getUserId(),
326                                    SocialActivityCounterConstants.NAME_CONTRIBUTION,
327                                    SocialActivityCounterConstants.TYPE_CREATOR);
328    
329                    SocialActivityCounter latestPopularityActivityCounter =
330                            fetchLatestActivityCounter(
331                                    assetEntry.getGroupId(), assetEntry.getClassNameId(),
332                                    assetEntry.getClassPK(),
333                                    SocialActivityCounterConstants.NAME_POPULARITY,
334                                    SocialActivityCounterConstants.TYPE_ASSET);
335    
336                    if ((latestContributionActivityCounter != null) &&
337                            (latestPopularityActivityCounter != null)) {
338    
339                            int startPeriod = SocialCounterPeriodUtil.getStartPeriod();
340    
341                            if (latestContributionActivityCounter.getStartPeriod() !=
342                                            startPeriod) {
343    
344                                    latestContributionActivityCounter = addActivityCounter(
345                                            latestContributionActivityCounter.getGroupId(),
346                                            latestContributionActivityCounter.getClassNameId(),
347                                            latestContributionActivityCounter.getClassPK(),
348                                            latestContributionActivityCounter.getName(),
349                                            latestContributionActivityCounter.getOwnerType(), 0,
350                                            latestContributionActivityCounter.getTotalValue(),
351                                            SocialCounterPeriodUtil.getStartPeriod(),
352                                            SocialActivityCounterConstants.END_PERIOD_UNDEFINED,
353                                            latestContributionActivityCounter.getActivityCounterId(),
354                                            SocialActivityCounterConstants.PERIOD_LENGTH_SYSTEM);
355                            }
356    
357                            if (latestPopularityActivityCounter.getStartPeriod() ==
358                                            startPeriod) {
359    
360                                    latestContributionActivityCounter.setCurrentValue(
361                                            latestContributionActivityCounter.getCurrentValue() -
362                                                    latestPopularityActivityCounter.getCurrentValue());
363                            }
364    
365                            latestContributionActivityCounter.setTotalValue(
366                                    latestContributionActivityCounter.getTotalValue() -
367                                            latestPopularityActivityCounter.getTotalValue());
368    
369                            socialActivityCounterPersistence.update(
370                                    latestContributionActivityCounter, false);
371                    }
372    
373                    deleteActivityCounters(
374                            assetEntry.getClassNameId(), assetEntry.getClassPK());
375    
376                    socialActivityLimitPersistence.removeByC_C(
377                            assetEntry.getClassNameId(), assetEntry.getClassPK());
378            }
379    
380            public void deleteActivityCounters(long classNameId, long classPK)
381                    throws SystemException {
382    
383                    socialActivityCounterPersistence.removeByC_C(classNameId, classPK);
384            }
385    
386            public SocialActivityCounter fetchActivityCounterByEndPeriod(
387                            long groupId, long classNameId, long classPK, String name,
388                            int ownerType, int endPeriod)
389                    throws SystemException {
390    
391                    return socialActivityCounterPersistence.fetchByG_C_C_N_O_E(
392                            groupId, classNameId, classPK, name, ownerType, endPeriod);
393            }
394    
395            public SocialActivityCounter fetchActivityCounterByStartPeriod(
396                            long groupId, long classNameId, long classPK, String name,
397                            int ownerType, int startPeriod)
398                    throws SystemException {
399    
400                    return socialActivityCounterPersistence.fetchByG_C_C_N_O_S(
401                            groupId, classNameId, classPK, name, ownerType, startPeriod);
402            }
403    
404            public SocialActivityCounter fetchLatestActivityCounter(
405                            long groupId, long classNameId, long classPK, String name,
406                            int ownerType)
407                    throws SystemException {
408    
409                    return socialActivityCounterPersistence.fetchByG_C_C_N_O_E(
410                            groupId, classNameId, classPK, name, ownerType,
411                            SocialActivityCounterConstants.END_PERIOD_UNDEFINED);
412            }
413    
414            public List<SocialActivityCounter> getOffsetActivityCounters(
415                            long groupId, String name, int startOffset, int endOffset)
416                    throws SystemException {
417    
418                    int startPeriod = SocialCounterPeriodUtil.getStartPeriod(startOffset);
419                    int endPeriod = SocialCounterPeriodUtil.getEndPeriod(endOffset);
420    
421                    return getPeriodActivityCounters(groupId, name, startPeriod, endPeriod);
422            }
423    
424            public List<SocialActivityCounter> getOffsetDistributionActivityCounters(
425                            long groupId, String name, int startOffset, int endOffset)
426                    throws SystemException {
427    
428                    int startPeriod = SocialCounterPeriodUtil.getStartPeriod(startOffset);
429                    int endPeriod = SocialCounterPeriodUtil.getEndPeriod(endOffset);
430    
431                    return getPeriodDistributionActivityCounters(
432                            groupId, name, startPeriod, endPeriod);
433            }
434    
435            public List<SocialActivityCounter> getPeriodActivityCounters(
436                            long groupId, String name, int startPeriod, int endPeriod)
437                    throws SystemException {
438    
439                    int offset = SocialCounterPeriodUtil.getOffset(endPeriod);
440    
441                    int periodLength = SocialCounterPeriodUtil.getPeriodLength(offset);
442    
443                    return socialActivityCounterFinder.findAC_ByG_N_S_E_1(
444                            groupId, name, startPeriod, endPeriod, periodLength);
445            }
446    
447            public List<SocialActivityCounter> getPeriodDistributionActivityCounters(
448                            long groupId, String name, int startPeriod, int endPeriod)
449                    throws SystemException {
450    
451                    int offset = SocialCounterPeriodUtil.getOffset(endPeriod);
452    
453                    int periodLength = SocialCounterPeriodUtil.getPeriodLength(offset);
454    
455                    return socialActivityCounterFinder.findAC_ByG_N_S_E_2(
456                            groupId, name, startPeriod, endPeriod, periodLength);
457            }
458    
459            public List<Tuple> getUserActivityCounters(
460                            long groupId, String[] rankingNames, String[] selectedNames,
461                            int start, int end)
462                    throws SystemException {
463    
464                    List<Long> userIds = socialActivityCounterFinder.findU_ByG_N(
465                            groupId, rankingNames, start, end);
466    
467                    if (userIds.isEmpty()) {
468                            return Collections.emptyList();
469                    }
470    
471                    Tuple[] userActivityCounters = new Tuple[userIds.size()];
472    
473                    List<SocialActivityCounter> activityCounters =
474                            SocialActivityCounterFinderUtil.findAC_By_G_C_C_N_S_E(
475                                    groupId, userIds, selectedNames, QueryUtil.ALL_POS,
476                                    QueryUtil.ALL_POS);
477    
478                    long userId = 0;
479                    Map<String, SocialActivityCounter> activityCountersMap = null;
480    
481                    for (SocialActivityCounter activityCounter : activityCounters) {
482                            if (userId != activityCounter.getClassPK()) {
483                                    userId = activityCounter.getClassPK();
484                                    activityCountersMap =
485                                            new HashMap<String, SocialActivityCounter>();
486    
487                                    Tuple userActivityCounter = new Tuple(
488                                            userId, activityCountersMap);
489    
490                                    for (int i = 0; i < userIds.size(); i++) {
491                                            long curUserId = userIds.get(i);
492    
493                                            if (userId == curUserId) {
494                                                    userActivityCounters[i] = userActivityCounter;
495    
496                                                    break;
497                                            }
498                                    }
499                            }
500    
501                            activityCountersMap.put(activityCounter.getName(), activityCounter);
502                    }
503    
504                    return Arrays.asList(userActivityCounters);
505            }
506    
507            public int getUserActivityCountersCount(long groupId, String[] rankingNames)
508                    throws SystemException {
509    
510                    return SocialActivityCounterFinderUtil.countU_ByG_N(
511                            groupId, rankingNames);
512            }
513    
514            public void incrementUserAchievementCounter(long userId, long groupId)
515                    throws PortalException, SystemException {
516    
517                    incrementActivityCounter(
518                            groupId, PortalUtil.getClassNameId(User.class.getName()), userId,
519                            SocialActivityCounterConstants.NAME_USER_ACHIEVEMENTS,
520                            SocialActivityCounterConstants.TYPE_ACTOR, 1,
521                            SocialActivityCounterConstants.PERIOD_LENGTH_SYSTEM);
522            }
523    
524            protected boolean addActivityCounter(
525                    User user, User assetEntryUser,
526                    SocialActivityCounterDefinition activityCounterDefinition) {
527    
528                    if ((user.isDefaultUser() || !user.isActive()) &&
529                            (activityCounterDefinition.getOwnerType() !=
530                                    SocialActivityCounterConstants.TYPE_ASSET)) {
531    
532                            return false;
533                    }
534    
535                    if ((assetEntryUser.isDefaultUser() || !assetEntryUser.isActive()) &&
536                            (activityCounterDefinition.getOwnerType() !=
537                                    SocialActivityCounterConstants.TYPE_ACTOR)) {
538    
539                            return false;
540                    }
541    
542                    if (!activityCounterDefinition.isEnabled() ||
543                            (activityCounterDefinition.getIncrement() == 0)) {
544    
545                            return false;
546                    }
547    
548                    String name = activityCounterDefinition.getName();
549    
550                    if ((user.getUserId() == assetEntryUser.getUserId()) &&
551                            (name.equals(SocialActivityCounterConstants.NAME_CONTRIBUTION) ||
552                             name.equals(SocialActivityCounterConstants.NAME_POPULARITY))) {
553    
554                            return false;
555                    }
556    
557                    return true;
558            }
559    
560            protected boolean checkActivityLimit(
561                            User user, SocialActivity activity,
562                            SocialActivityCounterDefinition activityCounterDefinition)
563                    throws PortalException, SystemException {
564    
565                    if (activityCounterDefinition.getLimitValue() == 0) {
566                            return true;
567                    }
568    
569                    long classPK = activity.getClassPK();
570    
571                    String name = activityCounterDefinition.getName();
572    
573                    if (name.equals(SocialActivityCounterConstants.NAME_PARTICIPATION)) {
574                            classPK = 0;
575                    }
576    
577                    SocialActivityLimit activityLimit =
578                            socialActivityLimitPersistence.fetchByG_U_C_C_A_A(
579                                    activity.getGroupId(), user.getUserId(),
580                                    activity.getClassNameId(), classPK, activity.getType(),
581                                    activityCounterDefinition.getName());
582    
583                    if (activityLimit == null) {
584                            try {
585                                    activityLimit =
586                                            socialActivityLimitLocalService.addActivityLimit(
587                                                    user.getUserId(), activity.getGroupId(),
588                                                    activity.getClassNameId(), classPK, activity.getType(),
589                                                    activityCounterDefinition.getName(),
590                                                    activityCounterDefinition.getLimitPeriod());
591                            }
592                            catch (SystemException se) {
593                                    activityLimit =
594                                            socialActivityLimitPersistence.fetchByG_U_C_C_A_A(
595                                                    activity.getGroupId(), user.getUserId(),
596                                                    activity.getClassNameId(), classPK, activity.getType(),
597                                                    activityCounterDefinition.getName());
598    
599                                    if (activityLimit == null) {
600                                            throw se;
601                                    }
602                            }
603                    }
604    
605                    int count = activityLimit.getCount(
606                            activityCounterDefinition.getLimitPeriod());
607    
608                    if (count < activityCounterDefinition.getLimitValue()) {
609                            activityLimit.setCount(
610                                    activityCounterDefinition.getLimitPeriod(), count + 1);
611    
612                            socialActivityLimitPersistence.update(activityLimit, false);
613    
614                            return true;
615                    }
616    
617                    return false;
618            }
619    
620            protected String getLockKey(
621                    long groupId, long classNameId, long classPK, String name,
622                    int ownerType) {
623    
624                    StringBundler sb = new StringBundler(7);
625    
626                    sb.append(StringUtil.toHexString(groupId));
627                    sb.append(StringPool.POUND);
628                    sb.append(StringUtil.toHexString(classNameId));
629                    sb.append(StringPool.POUND);
630                    sb.append(StringUtil.toHexString(classPK));
631                    sb.append(StringPool.POUND);
632                    sb.append(name);
633    
634                    return sb.toString();
635            }
636    
637            protected void incrementActivityCounter(
638                            long groupId, long classNameId, long classPK, String name,
639                            int ownerType, int increment, int periodLength)
640                    throws PortalException, SystemException {
641    
642                    SocialActivityCounter activityCounter = fetchLatestActivityCounter(
643                            groupId, classNameId, classPK, name, ownerType);
644    
645                    if (activityCounter == null) {
646                            activityCounter = addActivityCounter(
647                                    groupId, classNameId, classPK, name, ownerType, 0, 0,
648                                    SocialCounterPeriodUtil.getStartPeriod(),
649                                    SocialActivityCounterConstants.END_PERIOD_UNDEFINED);
650    
651                            if (periodLength > 0) {
652                                    activityCounter.setStartPeriod(
653                                            SocialCounterPeriodUtil.getActivityDay());
654                            }
655                    }
656    
657                    if (!activityCounter.isActivePeriod(periodLength)) {
658                            activityCounter = addActivityCounter(
659                                    activityCounter.getGroupId(), activityCounter.getClassNameId(),
660                                    activityCounter.getClassPK(), activityCounter.getName(),
661                                    activityCounter.getOwnerType(), 0,
662                                    activityCounter.getTotalValue(),
663                                    SocialCounterPeriodUtil.getStartPeriod(),
664                                    SocialActivityCounterConstants.END_PERIOD_UNDEFINED,
665                                    activityCounter.getActivityCounterId(), periodLength);
666                    }
667    
668                    activityCounter.setCurrentValue(
669                            activityCounter.getCurrentValue() + increment);
670                    activityCounter.setTotalValue(
671                            activityCounter.getTotalValue() + increment);
672    
673                    socialActivityCounterPersistence.update(activityCounter, false);
674            }
675    
676            protected void incrementActivityCounter(
677                            long groupId, User user, AssetEntry assetEntry,
678                            SocialActivityCounterDefinition activityCounterDefinition)
679                    throws PortalException, SystemException {
680    
681                    int ownerType = activityCounterDefinition.getOwnerType();
682                    long userClassNameId = PortalUtil.getClassNameId(User.class.getName());
683    
684                    if (ownerType == SocialActivityCounterConstants.TYPE_ACTOR) {
685                            incrementActivityCounter(
686                                    groupId, userClassNameId, user.getUserId(),
687                                    activityCounterDefinition.getName(), ownerType,
688                                    activityCounterDefinition.getIncrement(),
689                                    activityCounterDefinition.getPeriodLength());
690                    }
691                    else if (ownerType == SocialActivityCounterConstants.TYPE_ASSET) {
692                            incrementActivityCounter(
693                                    groupId, assetEntry.getClassNameId(), assetEntry.getClassPK(),
694                                    activityCounterDefinition.getName(), ownerType,
695                                    activityCounterDefinition.getIncrement(),
696                                    activityCounterDefinition.getPeriodLength());
697                    }
698                    else {
699                            incrementActivityCounter(
700                                    groupId, userClassNameId, assetEntry.getUserId(),
701                                    activityCounterDefinition.getName(), ownerType,
702                                    activityCounterDefinition.getIncrement(),
703                                    activityCounterDefinition.getPeriodLength());
704                    }
705            }
706    
707            private static Log _log = LogFactoryUtil.getLog(
708                    SocialActivityCounterLocalService.class);
709    
710    }