001
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
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
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
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 }