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.social.kernel.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.service.ServiceWrapper; 020 021 /** 022 * Provides a wrapper for {@link SocialActivityCounterLocalService}. 023 * 024 * @author Brian Wing Shun Chan 025 * @see SocialActivityCounterLocalService 026 * @generated 027 */ 028 @ProviderType 029 public class SocialActivityCounterLocalServiceWrapper 030 implements SocialActivityCounterLocalService, 031 ServiceWrapper<SocialActivityCounterLocalService> { 032 public SocialActivityCounterLocalServiceWrapper( 033 SocialActivityCounterLocalService socialActivityCounterLocalService) { 034 _socialActivityCounterLocalService = socialActivityCounterLocalService; 035 } 036 037 @Override 038 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 039 return _socialActivityCounterLocalService.getActionableDynamicQuery(); 040 } 041 042 @Override 043 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 044 return _socialActivityCounterLocalService.dynamicQuery(); 045 } 046 047 @Override 048 public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() { 049 return _socialActivityCounterLocalService.getIndexableActionableDynamicQuery(); 050 } 051 052 /** 053 * @throws PortalException 054 */ 055 @Override 056 public com.liferay.portal.kernel.model.PersistedModel deletePersistedModel( 057 com.liferay.portal.kernel.model.PersistedModel persistedModel) 058 throws com.liferay.portal.kernel.exception.PortalException { 059 return _socialActivityCounterLocalService.deletePersistedModel(persistedModel); 060 } 061 062 @Override 063 public com.liferay.portal.kernel.model.PersistedModel getPersistedModel( 064 java.io.Serializable primaryKeyObj) 065 throws com.liferay.portal.kernel.exception.PortalException { 066 return _socialActivityCounterLocalService.getPersistedModel(primaryKeyObj); 067 } 068 069 /** 070 * Adds an activity counter specifying a previous activity and period 071 * length. 072 * 073 * <p> 074 * This method uses the lock service to guard against multiple threads 075 * trying to insert the same counter because this service is called 076 * asynchronously from the social activity service. 077 * </p> 078 * 079 * @param groupId the primary key of the group 080 * @param classNameId the primary key of the entity's class this counter 081 belongs to 082 * @param classPK the primary key of the entity this counter belongs to 083 * @param name the counter name 084 * @param ownerType the counter's owner type. Acceptable values are 085 <code>TYPE_ACTOR</code>, <code>TYPE_ASSET</code> and 086 <code>TYPE_CREATOR</code> defined in {@link 087 SocialActivityCounterConstants}. 088 * @param totalValue the counter's total value (optionally <code>0</code>) 089 * @param previousActivityCounterId the primary key of the activity counter 090 for the previous time period (optionally <code>0</code>, if this 091 is the first) 092 * @param periodLength the period length in days, 093 <code>PERIOD_LENGTH_INFINITE</code> for never ending counters or 094 <code>PERIOD_LENGTH_SYSTEM</code> for the period length defined 095 in <code>portal-ext.properties</code>. For more information see 096 {@link SocialActivityCounterConstants}. 097 * @return the added activity counter 098 */ 099 @Override 100 public com.liferay.social.kernel.model.SocialActivityCounter addActivityCounter( 101 long groupId, long classNameId, long classPK, java.lang.String name, 102 int ownerType, int totalValue, long previousActivityCounterId, 103 int periodLength) 104 throws com.liferay.portal.kernel.exception.PortalException { 105 return _socialActivityCounterLocalService.addActivityCounter(groupId, 106 classNameId, classPK, name, ownerType, totalValue, 107 previousActivityCounterId, periodLength); 108 } 109 110 /** 111 * Adds the social activity counter to the database. Also notifies the appropriate model listeners. 112 * 113 * @param socialActivityCounter the social activity counter 114 * @return the social activity counter that was added 115 */ 116 @Override 117 public com.liferay.social.kernel.model.SocialActivityCounter addSocialActivityCounter( 118 com.liferay.social.kernel.model.SocialActivityCounter socialActivityCounter) { 119 return _socialActivityCounterLocalService.addSocialActivityCounter(socialActivityCounter); 120 } 121 122 /** 123 * Creates a new social activity counter with the primary key. Does not add the social activity counter to the database. 124 * 125 * @param activityCounterId the primary key for the new social activity counter 126 * @return the new social activity counter 127 */ 128 @Override 129 public com.liferay.social.kernel.model.SocialActivityCounter createSocialActivityCounter( 130 long activityCounterId) { 131 return _socialActivityCounterLocalService.createSocialActivityCounter(activityCounterId); 132 } 133 134 /** 135 * Deletes the social activity counter from the database. Also notifies the appropriate model listeners. 136 * 137 * @param socialActivityCounter the social activity counter 138 * @return the social activity counter that was removed 139 */ 140 @Override 141 public com.liferay.social.kernel.model.SocialActivityCounter deleteSocialActivityCounter( 142 com.liferay.social.kernel.model.SocialActivityCounter socialActivityCounter) { 143 return _socialActivityCounterLocalService.deleteSocialActivityCounter(socialActivityCounter); 144 } 145 146 /** 147 * Deletes the social activity counter with the primary key from the database. Also notifies the appropriate model listeners. 148 * 149 * @param activityCounterId the primary key of the social activity counter 150 * @return the social activity counter that was removed 151 * @throws PortalException if a social activity counter with the primary key could not be found 152 */ 153 @Override 154 public com.liferay.social.kernel.model.SocialActivityCounter deleteSocialActivityCounter( 155 long activityCounterId) 156 throws com.liferay.portal.kernel.exception.PortalException { 157 return _socialActivityCounterLocalService.deleteSocialActivityCounter(activityCounterId); 158 } 159 160 /** 161 * Returns the activity counter with the given name, owner, and end period 162 * that belong to the given entity. 163 * 164 * @param groupId the primary key of the group 165 * @param classNameId the primary key of the entity's class 166 * @param classPK the primary key of the entity 167 * @param name the counter name 168 * @param ownerType the owner type 169 * @param endPeriod the end period, <code>-1</code> for the latest one 170 * @return the matching activity counter 171 */ 172 @Override 173 public com.liferay.social.kernel.model.SocialActivityCounter fetchActivityCounterByEndPeriod( 174 long groupId, long classNameId, long classPK, java.lang.String name, 175 int ownerType, int endPeriod) { 176 return _socialActivityCounterLocalService.fetchActivityCounterByEndPeriod(groupId, 177 classNameId, classPK, name, ownerType, endPeriod); 178 } 179 180 /** 181 * Returns the activity counter with the given name, owner, and start period 182 * that belong to the given entity. 183 * 184 * @param groupId the primary key of the group 185 * @param classNameId the primary key of the entity's class 186 * @param classPK the primary key of the entity 187 * @param name the counter name 188 * @param ownerType the owner type 189 * @param startPeriod the start period 190 * @return the matching activity counter 191 */ 192 @Override 193 public com.liferay.social.kernel.model.SocialActivityCounter fetchActivityCounterByStartPeriod( 194 long groupId, long classNameId, long classPK, java.lang.String name, 195 int ownerType, int startPeriod) { 196 return _socialActivityCounterLocalService.fetchActivityCounterByStartPeriod(groupId, 197 classNameId, classPK, name, ownerType, startPeriod); 198 } 199 200 /** 201 * Returns the latest activity counter with the given name and owner that 202 * belong to the given entity. 203 * 204 * @param groupId the primary key of the group 205 * @param classNameId the primary key of the entity's class 206 * @param classPK the primary key of the entity 207 * @param name the counter name 208 * @param ownerType the owner type 209 * @return the matching activity counter 210 */ 211 @Override 212 public com.liferay.social.kernel.model.SocialActivityCounter fetchLatestActivityCounter( 213 long groupId, long classNameId, long classPK, java.lang.String name, 214 int ownerType) { 215 return _socialActivityCounterLocalService.fetchLatestActivityCounter(groupId, 216 classNameId, classPK, name, ownerType); 217 } 218 219 @Override 220 public com.liferay.social.kernel.model.SocialActivityCounter fetchSocialActivityCounter( 221 long activityCounterId) { 222 return _socialActivityCounterLocalService.fetchSocialActivityCounter(activityCounterId); 223 } 224 225 /** 226 * Returns the social activity counter with the primary key. 227 * 228 * @param activityCounterId the primary key of the social activity counter 229 * @return the social activity counter 230 * @throws PortalException if a social activity counter with the primary key could not be found 231 */ 232 @Override 233 public com.liferay.social.kernel.model.SocialActivityCounter getSocialActivityCounter( 234 long activityCounterId) 235 throws com.liferay.portal.kernel.exception.PortalException { 236 return _socialActivityCounterLocalService.getSocialActivityCounter(activityCounterId); 237 } 238 239 /** 240 * Updates the social activity counter in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 241 * 242 * @param socialActivityCounter the social activity counter 243 * @return the social activity counter that was updated 244 */ 245 @Override 246 public com.liferay.social.kernel.model.SocialActivityCounter updateSocialActivityCounter( 247 com.liferay.social.kernel.model.SocialActivityCounter socialActivityCounter) { 248 return _socialActivityCounterLocalService.updateSocialActivityCounter(socialActivityCounter); 249 } 250 251 /** 252 * Returns the number of social activity counters. 253 * 254 * @return the number of social activity counters 255 */ 256 @Override 257 public int getSocialActivityCountersCount() { 258 return _socialActivityCounterLocalService.getSocialActivityCountersCount(); 259 } 260 261 /** 262 * Returns the number of users having a rank based on the given counters. 263 * 264 * @param groupId the primary key of the group 265 * @param rankingNames the ranking counter names 266 * @return the number of matching users 267 */ 268 @Override 269 public int getUserActivityCountersCount(long groupId, 270 java.lang.String[] rankingNames) { 271 return _socialActivityCounterLocalService.getUserActivityCountersCount(groupId, 272 rankingNames); 273 } 274 275 /** 276 * Returns the OSGi service identifier. 277 * 278 * @return the OSGi service identifier 279 */ 280 @Override 281 public java.lang.String getOSGiServiceIdentifier() { 282 return _socialActivityCounterLocalService.getOSGiServiceIdentifier(); 283 } 284 285 /** 286 * Performs a dynamic query on the database and returns the matching rows. 287 * 288 * @param dynamicQuery the dynamic query 289 * @return the matching rows 290 */ 291 @Override 292 public <T> java.util.List<T> dynamicQuery( 293 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 294 return _socialActivityCounterLocalService.dynamicQuery(dynamicQuery); 295 } 296 297 /** 298 * Performs a dynamic query on the database and returns a range of the matching rows. 299 * 300 * <p> 301 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.social.model.impl.SocialActivityCounterModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 302 * </p> 303 * 304 * @param dynamicQuery the dynamic query 305 * @param start the lower bound of the range of model instances 306 * @param end the upper bound of the range of model instances (not inclusive) 307 * @return the range of matching rows 308 */ 309 @Override 310 public <T> java.util.List<T> dynamicQuery( 311 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 312 int end) { 313 return _socialActivityCounterLocalService.dynamicQuery(dynamicQuery, 314 start, end); 315 } 316 317 /** 318 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 319 * 320 * <p> 321 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.social.model.impl.SocialActivityCounterModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 322 * </p> 323 * 324 * @param dynamicQuery the dynamic query 325 * @param start the lower bound of the range of model instances 326 * @param end the upper bound of the range of model instances (not inclusive) 327 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 328 * @return the ordered range of matching rows 329 */ 330 @Override 331 public <T> java.util.List<T> dynamicQuery( 332 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 333 int end, 334 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 335 return _socialActivityCounterLocalService.dynamicQuery(dynamicQuery, 336 start, end, orderByComparator); 337 } 338 339 /** 340 * Returns all the activity counters with the given name and period offsets. 341 * 342 * <p> 343 * The start and end offsets can belong to different periods. This method 344 * groups the counters by name and returns the sum of their current values. 345 * </p> 346 * 347 * @param groupId the primary key of the group 348 * @param name the counter name 349 * @param startOffset the offset for the start period 350 * @param endOffset the offset for the end period 351 * @return the matching activity counters 352 */ 353 @Override 354 public java.util.List<com.liferay.social.kernel.model.SocialActivityCounter> getOffsetActivityCounters( 355 long groupId, java.lang.String name, int startOffset, int endOffset) { 356 return _socialActivityCounterLocalService.getOffsetActivityCounters(groupId, 357 name, startOffset, endOffset); 358 } 359 360 /** 361 * Returns the distribution of the activity counters with the given name and 362 * period offsets. 363 * 364 * <p> 365 * The start and end offsets can belong to different periods. This method 366 * groups the counters by their owner entity (usually some asset) and 367 * returns a counter for each entity class with the sum of the counters' 368 * current values. 369 * </p> 370 * 371 * @param groupId the primary key of the group 372 * @param name the counter name 373 * @param startOffset the offset for the start period 374 * @param endOffset the offset for the end period 375 * @return the distribution of matching activity counters 376 */ 377 @Override 378 public java.util.List<com.liferay.social.kernel.model.SocialActivityCounter> getOffsetDistributionActivityCounters( 379 long groupId, java.lang.String name, int startOffset, int endOffset) { 380 return _socialActivityCounterLocalService.getOffsetDistributionActivityCounters(groupId, 381 name, startOffset, endOffset); 382 } 383 384 /** 385 * Returns all the activity counters with the given name and time period. 386 * 387 * <p> 388 * The start and end period values can belong to different periods. This 389 * method groups the counters by name and returns the sum of their current 390 * values. 391 * </p> 392 * 393 * @param groupId the primary key of the group 394 * @param name the counter name 395 * @param startPeriod the start period 396 * @param endPeriod the end period 397 * @return the matching activity counters 398 */ 399 @Override 400 public java.util.List<com.liferay.social.kernel.model.SocialActivityCounter> getPeriodActivityCounters( 401 long groupId, java.lang.String name, int startPeriod, int endPeriod) { 402 return _socialActivityCounterLocalService.getPeriodActivityCounters(groupId, 403 name, startPeriod, endPeriod); 404 } 405 406 /** 407 * Returns the distribution of activity counters with the given name and 408 * time period. 409 * 410 * <p> 411 * The start and end period values can belong to different periods. This 412 * method groups the counters by their owner entity (usually some asset) and 413 * returns a counter for each entity class with the sum of the counters' 414 * current values. 415 * </p> 416 * 417 * @param groupId the primary key of the group 418 * @param name the counter name 419 * @param startPeriod the start period 420 * @param endPeriod the end period 421 * @return the distribution of matching activity counters 422 */ 423 @Override 424 public java.util.List<com.liferay.social.kernel.model.SocialActivityCounter> getPeriodDistributionActivityCounters( 425 long groupId, java.lang.String name, int startPeriod, int endPeriod) { 426 return _socialActivityCounterLocalService.getPeriodDistributionActivityCounters(groupId, 427 name, startPeriod, endPeriod); 428 } 429 430 /** 431 * Returns a range of all the social activity counters. 432 * 433 * <p> 434 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.social.model.impl.SocialActivityCounterModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 435 * </p> 436 * 437 * @param start the lower bound of the range of social activity counters 438 * @param end the upper bound of the range of social activity counters (not inclusive) 439 * @return the range of social activity counters 440 */ 441 @Override 442 public java.util.List<com.liferay.social.kernel.model.SocialActivityCounter> getSocialActivityCounters( 443 int start, int end) { 444 return _socialActivityCounterLocalService.getSocialActivityCounters(start, 445 end); 446 } 447 448 /** 449 * Returns the range of tuples that contain users and a list of activity 450 * counters. 451 * 452 * <p> 453 * The counters returned for each user are passed to this method in the 454 * selectedNames array. The method also accepts an array of counter names 455 * that are used to rank the users. 456 * </p> 457 * 458 * <p> 459 * Useful when paginating results. Returns a maximum of <code>end - 460 * start</code> instances. <code>start</code> and <code>end</code> are not 461 * primary keys, they are indexes in the result set. Thus, <code>0</code> 462 * refers to the first result in the set. Setting both <code>start</code> 463 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 464 * result set. 465 * </p> 466 * 467 * @param groupId the primary key of the group 468 * @param rankingNames the ranking counter names 469 * @param selectedNames the counter names that will be returned with each 470 user 471 * @param start the lower bound of the range of results 472 * @param end the upper bound of the range of results (not inclusive) 473 * @return the range of matching tuples 474 */ 475 @Override 476 public java.util.List<com.liferay.portal.kernel.util.Tuple> getUserActivityCounters( 477 long groupId, java.lang.String[] rankingNames, 478 java.lang.String[] selectedNames, int start, int end) { 479 return _socialActivityCounterLocalService.getUserActivityCounters(groupId, 480 rankingNames, selectedNames, start, end); 481 } 482 483 /** 484 * Returns the number of rows matching the dynamic query. 485 * 486 * @param dynamicQuery the dynamic query 487 * @return the number of rows matching the dynamic query 488 */ 489 @Override 490 public long dynamicQueryCount( 491 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 492 return _socialActivityCounterLocalService.dynamicQueryCount(dynamicQuery); 493 } 494 495 /** 496 * Returns the number of rows matching the dynamic query. 497 * 498 * @param dynamicQuery the dynamic query 499 * @param projection the projection to apply to the query 500 * @return the number of rows matching the dynamic query 501 */ 502 @Override 503 public long dynamicQueryCount( 504 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 505 com.liferay.portal.kernel.dao.orm.Projection projection) { 506 return _socialActivityCounterLocalService.dynamicQueryCount(dynamicQuery, 507 projection); 508 } 509 510 /** 511 * Adds or increments activity counters related to an activity. 512 * 513 * </p> 514 * This method is called asynchronously from the social activity service 515 * when the user performs an activity defined in 516 * </code>liferay-social.xml</code>. 517 * </p> 518 * 519 * <p> 520 * This method first calls the activity processor class, if there is one 521 * defined for the activity, checks for limits and increments all the 522 * counters that belong to the activity. Afterwards, it processes the 523 * activity with respect to achievement classes, if any. Lastly it 524 * increments the built-in <code>user.activities</code> and 525 * <code>asset.activities</code> counters. 526 * </p> 527 * 528 * @param activity the social activity 529 */ 530 @Override 531 public void addActivityCounters( 532 com.liferay.social.kernel.model.SocialActivity activity) 533 throws com.liferay.portal.kernel.exception.PortalException { 534 _socialActivityCounterLocalService.addActivityCounters(activity); 535 } 536 537 /** 538 * Deletes all activity counters, limits, and settings related to the asset. 539 * 540 * <p> 541 * This method subtracts the asset's popularity from the owner's 542 * contribution points. It also creates a new contribution period if the 543 * latest one does not belong to the current period. 544 * </p> 545 * 546 * @param assetEntry the asset entry 547 */ 548 @Override 549 public void deleteActivityCounters( 550 com.liferay.asset.kernel.model.AssetEntry assetEntry) 551 throws com.liferay.portal.kernel.exception.PortalException { 552 _socialActivityCounterLocalService.deleteActivityCounters(assetEntry); 553 } 554 555 /** 556 * Deletes all activity counters for the entity identified by the class name 557 * and class primary key. 558 * 559 * @param className the entity's class name 560 * @param classPK the primary key of the entity 561 */ 562 @Override 563 public void deleteActivityCounters(java.lang.String className, long classPK) 564 throws com.liferay.portal.kernel.exception.PortalException { 565 _socialActivityCounterLocalService.deleteActivityCounters(className, 566 classPK); 567 } 568 569 /** 570 * Deletes all activity counters, limits, and settings related to the entity 571 * identified by the class name ID and class primary key. 572 * 573 * @param classNameId the primary key of the entity's class 574 * @param classPK the primary key of the entity 575 */ 576 @Override 577 public void deleteActivityCounters(long classNameId, long classPK) 578 throws com.liferay.portal.kernel.exception.PortalException { 579 _socialActivityCounterLocalService.deleteActivityCounters(classNameId, 580 classPK); 581 } 582 583 /** 584 * Disables all the counters of an asset identified by the class name and 585 * class primary key. 586 * 587 * <p> 588 * This method is used by the recycle bin to disable all counters of assets 589 * put into the recycle bin. It adjusts the owner's contribution score. 590 * </p> 591 * 592 * @param className the asset's class name 593 * @param classPK the primary key of the asset 594 */ 595 @Override 596 public void disableActivityCounters(java.lang.String className, long classPK) 597 throws com.liferay.portal.kernel.exception.PortalException { 598 _socialActivityCounterLocalService.disableActivityCounters(className, 599 classPK); 600 } 601 602 /** 603 * Disables all the counters of an asset identified by the class name ID and 604 * class primary key. 605 * 606 * <p> 607 * This method is used by the recycle bin to disable all counters of assets 608 * put into the recycle bin. It adjusts the owner's contribution score. 609 * </p> 610 * 611 * @param classNameId the primary key of the asset's class 612 * @param classPK the primary key of the asset 613 */ 614 @Override 615 public void disableActivityCounters(long classNameId, long classPK) 616 throws com.liferay.portal.kernel.exception.PortalException { 617 _socialActivityCounterLocalService.disableActivityCounters(classNameId, 618 classPK); 619 } 620 621 /** 622 * Enables all the counters of an asset identified by the class name and 623 * class primary key. 624 * 625 * <p> 626 * This method is used by the recycle bin to enable all counters of assets 627 * restored from the recycle bin. It adjusts the owner's contribution score. 628 * </p> 629 * 630 * @param className the asset's class name 631 * @param classPK the primary key of the asset 632 */ 633 @Override 634 public void enableActivityCounters(java.lang.String className, long classPK) 635 throws com.liferay.portal.kernel.exception.PortalException { 636 _socialActivityCounterLocalService.enableActivityCounters(className, 637 classPK); 638 } 639 640 /** 641 * Enables all activity counters of an asset identified by the class name ID 642 * and class primary key. 643 * 644 * <p> 645 * This method is used by the recycle bin to enable all counters of assets 646 * restored from the recycle bin. It adjusts the owner's contribution score. 647 * </p> 648 * 649 * @param classNameId the primary key of the asset's class 650 * @param classPK the primary key of the asset 651 */ 652 @Override 653 public void enableActivityCounters(long classNameId, long classPK) 654 throws com.liferay.portal.kernel.exception.PortalException { 655 _socialActivityCounterLocalService.enableActivityCounters(classNameId, 656 classPK); 657 } 658 659 /** 660 * Increments the <code>user.achievements</code> counter for a user. 661 * 662 * <p> 663 * This method should be used by an external achievement class when the 664 * users unlocks an achievement. 665 * </p> 666 * 667 * @param userId the primary key of the user 668 * @param groupId the primary key of the group 669 */ 670 @Override 671 public void incrementUserAchievementCounter(long userId, long groupId) 672 throws com.liferay.portal.kernel.exception.PortalException { 673 _socialActivityCounterLocalService.incrementUserAchievementCounter(userId, 674 groupId); 675 } 676 677 @Override 678 public SocialActivityCounterLocalService getWrappedService() { 679 return _socialActivityCounterLocalService; 680 } 681 682 @Override 683 public void setWrappedService( 684 SocialActivityCounterLocalService socialActivityCounterLocalService) { 685 _socialActivityCounterLocalService = socialActivityCounterLocalService; 686 } 687 688 private SocialActivityCounterLocalService _socialActivityCounterLocalService; 689 }