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.portlet.social.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.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 /** 038 * Adds an activity counter with a default period length. 039 * 040 * <p> 041 * This method uses the lock service to guard against multiple threads 042 * trying to insert the same counter because this service is called 043 * asynchronously from the social activity service. 044 * </p> 045 * 046 * @param groupId the primary key of the group 047 * @param classNameId the primary key of the entity's class this 048 counter belongs to 049 * @param classPK the primary key of the entity this counter belongs to 050 * @param name the counter's name 051 * @param ownerType the counter's owner type. Acceptable values are 052 <code>TYPE_ACTOR</code>, <code>TYPE_ASSET</code> and 053 <code>TYPE_CREATOR</code> defined in {@link 054 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 055 * @param currentValue the counter's current value (optionally 056 <code>0</code>) 057 * @param totalValue the counter's total value (optionally 058 <code>0</code>) 059 * @param startPeriod the counter's start period 060 * @param endPeriod the counter's end period 061 * @return the added activity counter 062 * @throws PortalException if the group or the previous activity counter 063 could not be found 064 * @deprecated As of 6.2.0, replaced by {@link #addActivityCounter(long, 065 long, long, String, int, int, long, int)} 066 */ 067 @Deprecated 068 @Override 069 public com.liferay.portlet.social.model.SocialActivityCounter addActivityCounter( 070 long groupId, long classNameId, long classPK, java.lang.String name, 071 int ownerType, int currentValue, int totalValue, int startPeriod, 072 int endPeriod) 073 throws com.liferay.portal.kernel.exception.PortalException { 074 return _socialActivityCounterLocalService.addActivityCounter(groupId, 075 classNameId, classPK, name, ownerType, currentValue, totalValue, 076 startPeriod, endPeriod); 077 } 078 079 /** 080 * Adds an activity counter specifying a previous activity and period 081 * length. 082 * 083 * <p> 084 * This method uses the lock service to guard against multiple threads 085 * trying to insert the same counter because this service is called 086 * asynchronously from the social activity service. 087 * </p> 088 * 089 * @param groupId the primary key of the group 090 * @param classNameId the primary key of the entity's class this 091 counter belongs to 092 * @param classPK the primary key of the entity this counter belongs to 093 * @param name the counter name 094 * @param ownerType the counter's owner type. Acceptable values are 095 <code>TYPE_ACTOR</code>, <code>TYPE_ASSET</code> and 096 <code>TYPE_CREATOR</code> defined in {@link 097 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 098 * @param currentValue the current value of the counter (optionally 099 <code>0</code>) 100 * @param totalValue the counter's total value (optionally 101 <code>0</code>) 102 * @param startPeriod the counter's start period 103 * @param endPeriod the counter's end period 104 * @param previousActivityCounterId the primary key of the activity 105 counter for the previous time period (optionally 106 <code>0</code>, if this is the first) 107 * @param periodLength the period length in days, 108 <code>PERIOD_LENGTH_INFINITE</code> for never ending counters 109 or <code>PERIOD_LENGTH_SYSTEM</code> for the period length 110 defined in <code>portal-ext.properties</code>. For more 111 information see {@link 112 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 113 * @return the added activity counter 114 * @throws PortalException if the group or the previous activity counter 115 could not be found 116 * @deprecated As of 6.2.0, replaced by {@link #addActivityCounter(long, 117 long, long, String, int, int, long, int)} 118 */ 119 @Deprecated 120 @Override 121 public com.liferay.portlet.social.model.SocialActivityCounter addActivityCounter( 122 long groupId, long classNameId, long classPK, java.lang.String name, 123 int ownerType, int currentValue, int totalValue, int startPeriod, 124 int endPeriod, long previousActivityCounterId, int periodLength) 125 throws com.liferay.portal.kernel.exception.PortalException { 126 return _socialActivityCounterLocalService.addActivityCounter(groupId, 127 classNameId, classPK, name, ownerType, currentValue, totalValue, 128 startPeriod, endPeriod, previousActivityCounterId, periodLength); 129 } 130 131 /** 132 * Adds an activity counter specifying a previous activity and period 133 * length. 134 * 135 * <p> 136 * This method uses the lock service to guard against multiple threads 137 * trying to insert the same counter because this service is called 138 * asynchronously from the social activity service. 139 * </p> 140 * 141 * @param groupId the primary key of the group 142 * @param classNameId the primary key of the entity's class this counter 143 belongs to 144 * @param classPK the primary key of the entity this counter belongs to 145 * @param name the counter name 146 * @param ownerType the counter's owner type. Acceptable values are 147 <code>TYPE_ACTOR</code>, <code>TYPE_ASSET</code> and 148 <code>TYPE_CREATOR</code> defined in {@link 149 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 150 * @param totalValue the counter's total value (optionally <code>0</code>) 151 * @param previousActivityCounterId the primary key of the activity counter 152 for the previous time period (optionally <code>0</code>, if this 153 is the first) 154 * @param periodLength the period length in days, 155 <code>PERIOD_LENGTH_INFINITE</code> for never ending counters or 156 <code>PERIOD_LENGTH_SYSTEM</code> for the period length defined 157 in <code>portal-ext.properties</code>. For more information see 158 {@link 159 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 160 * @return the added activity counter 161 * @throws PortalException if the group or the previous activity counter 162 could not be found 163 */ 164 @Override 165 public com.liferay.portlet.social.model.SocialActivityCounter addActivityCounter( 166 long groupId, long classNameId, long classPK, java.lang.String name, 167 int ownerType, int totalValue, long previousActivityCounterId, 168 int periodLength) 169 throws com.liferay.portal.kernel.exception.PortalException { 170 return _socialActivityCounterLocalService.addActivityCounter(groupId, 171 classNameId, classPK, name, ownerType, totalValue, 172 previousActivityCounterId, periodLength); 173 } 174 175 /** 176 * Adds or increments activity counters related to an activity. 177 * 178 * </p> 179 * This method is called asynchronously from the social activity service 180 * when the user performs an activity defined in 181 * </code>liferay-social.xml</code>. 182 * </p> 183 * 184 * <p> 185 * This method first calls the activity processor class, if there is one 186 * defined for the activity, checks for limits and increments all the 187 * counters that belong to the activity. Afterwards, it processes the 188 * activity with respect to achievement classes, if any. Lastly it 189 * increments the built-in <code>user.activities</code> and 190 * <code>asset.activities</code> counters. 191 * </p> 192 * 193 * @param activity the social activity 194 * @throws PortalException if an expected group or expected previous 195 activity counters could not be found 196 */ 197 @Override 198 public void addActivityCounters( 199 com.liferay.portlet.social.model.SocialActivity activity) 200 throws com.liferay.portal.kernel.exception.PortalException { 201 _socialActivityCounterLocalService.addActivityCounters(activity); 202 } 203 204 /** 205 * Adds the social activity counter to the database. Also notifies the appropriate model listeners. 206 * 207 * @param socialActivityCounter the social activity counter 208 * @return the social activity counter that was added 209 */ 210 @Override 211 public com.liferay.portlet.social.model.SocialActivityCounter addSocialActivityCounter( 212 com.liferay.portlet.social.model.SocialActivityCounter socialActivityCounter) { 213 return _socialActivityCounterLocalService.addSocialActivityCounter(socialActivityCounter); 214 } 215 216 /** 217 * Creates an activity counter with a default period length, adding it into 218 * the database. 219 * 220 * @param groupId the primary key of the group 221 * @param classNameId the primary key of the entity's class this 222 counter belongs to 223 * @param classPK the primary key of the entity this counter belongs to 224 * @param name the counter's name 225 * @param ownerType the counter's owner type. Acceptable values are 226 <code>TYPE_ACTOR</code>, <code>TYPE_ASSET</code> and 227 <code>TYPE_CREATOR</code> defined in {@link 228 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 229 * @param currentValue the counter's current value (optionally 230 <code>0</code>) 231 * @param totalValue the counter's total value (optionally 232 <code>0</code>) 233 * @param startPeriod the counter's start period 234 * @param endPeriod the counter's end period 235 * @return the created activity counter 236 * @throws PortalException if the group or a previous activity counter 237 could not be found 238 * @deprecated As of 6.2.0, replaced by {@link #addActivityCounter(long, 239 long, long, String, int, int, long, int)} 240 */ 241 @Deprecated 242 @Override 243 public com.liferay.portlet.social.model.SocialActivityCounter createActivityCounter( 244 long groupId, long classNameId, long classPK, java.lang.String name, 245 int ownerType, int currentValue, int totalValue, int startPeriod, 246 int endPeriod) 247 throws com.liferay.portal.kernel.exception.PortalException { 248 return _socialActivityCounterLocalService.createActivityCounter(groupId, 249 classNameId, classPK, name, ownerType, currentValue, totalValue, 250 startPeriod, endPeriod); 251 } 252 253 /** 254 * Creates an activity counter, adding it into the database. 255 * 256 * <p> 257 * This method actually creates the counter in the database. It requires a 258 * new transaction so that other threads can find the new counter when the 259 * lock in the calling method is released. 260 * </p> 261 * 262 * @param groupId the primary key of the group 263 * @param classNameId the primary key of the entity's class this 264 counter belongs to 265 * @param classPK the primary key of the entity this counter belongs to 266 * @param name the counter's name 267 * @param ownerType the counter's owner type. Acceptable values are 268 <code>TYPE_ACTOR</code>, <code>TYPE_ASSET</code> and 269 <code>TYPE_CREATOR</code> defined in {@link 270 com.liferay.portlet.social.model.SocialActivityCounterConstants}. 271 * @param currentValue the counter's current value (optionally 272 <code>0</code>) 273 * @param totalValue the counter's total value of the counter 274 (optionally <code>0</code>) 275 * @param startPeriod the counter's start period 276 * @param endPeriod the counter's end period 277 * @param previousActivityCounterId the primary key of the activity 278 counter for the previous time period (optionally 279 <code>0</code>, if this is the first) 280 * @param periodLength the period length in days, 281 <code>PERIOD_LENGTH_INFINITE</code> for never ending counters 282 or <code>PERIOD_LENGTH_SYSTEM</code> for the period length 283 defined in <code>portal-ext.properties</code>. For more 284 information see {@link 285 com.liferay.portlet.social.model.SocialActivityConstants}. 286 * @return the created activity counter 287 * @throws PortalException if the group or the previous activity counter 288 could not be found 289 * @deprecated As of 6.2.0, replaced by {@link #addActivityCounter(long, 290 long, long, String, int, int, long, int)} 291 */ 292 @Deprecated 293 @Override 294 public com.liferay.portlet.social.model.SocialActivityCounter createActivityCounter( 295 long groupId, long classNameId, long classPK, java.lang.String name, 296 int ownerType, int currentValue, int totalValue, int startPeriod, 297 int endPeriod, long previousActivityCounterId, int periodLength) 298 throws com.liferay.portal.kernel.exception.PortalException { 299 return _socialActivityCounterLocalService.createActivityCounter(groupId, 300 classNameId, classPK, name, ownerType, currentValue, totalValue, 301 startPeriod, endPeriod, previousActivityCounterId, periodLength); 302 } 303 304 /** 305 * Creates a new social activity counter with the primary key. Does not add the social activity counter to the database. 306 * 307 * @param activityCounterId the primary key for the new social activity counter 308 * @return the new social activity counter 309 */ 310 @Override 311 public com.liferay.portlet.social.model.SocialActivityCounter createSocialActivityCounter( 312 long activityCounterId) { 313 return _socialActivityCounterLocalService.createSocialActivityCounter(activityCounterId); 314 } 315 316 /** 317 * Deletes all activity counters, limits, and settings related to the asset. 318 * 319 * <p> 320 * This method subtracts the asset's popularity from the owner's 321 * contribution points. It also creates a new contribution period if the 322 * latest one does not belong to the current period. 323 * </p> 324 * 325 * @param assetEntry the asset entry 326 * @throws PortalException if the new contribution counter could not be 327 created 328 */ 329 @Override 330 public void deleteActivityCounters( 331 com.liferay.portlet.asset.model.AssetEntry assetEntry) 332 throws com.liferay.portal.kernel.exception.PortalException { 333 _socialActivityCounterLocalService.deleteActivityCounters(assetEntry); 334 } 335 336 /** 337 * Deletes all activity counters for the entity identified by the class name 338 * and class primary key. 339 * 340 * @param className the entity's class name 341 * @param classPK the primary key of the entity 342 * @throws PortalException if the entity is an asset and its owner's 343 contribution counter could not be updated 344 */ 345 @Override 346 public void deleteActivityCounters(java.lang.String className, long classPK) 347 throws com.liferay.portal.kernel.exception.PortalException { 348 _socialActivityCounterLocalService.deleteActivityCounters(className, 349 classPK); 350 } 351 352 /** 353 * Deletes all activity counters, limits, and settings related to the entity 354 * identified by the class name ID and class primary key. 355 * 356 * @param classNameId the primary key of the entity's class 357 * @param classPK the primary key of the entity 358 * @throws PortalException if the entity is an asset and its owner's 359 contribution counter could not be updated 360 */ 361 @Override 362 public void deleteActivityCounters(long classNameId, long classPK) 363 throws com.liferay.portal.kernel.exception.PortalException { 364 _socialActivityCounterLocalService.deleteActivityCounters(classNameId, 365 classPK); 366 } 367 368 /** 369 * @throws PortalException 370 */ 371 @Override 372 public com.liferay.portal.model.PersistedModel deletePersistedModel( 373 com.liferay.portal.model.PersistedModel persistedModel) 374 throws com.liferay.portal.kernel.exception.PortalException { 375 return _socialActivityCounterLocalService.deletePersistedModel(persistedModel); 376 } 377 378 /** 379 * Deletes the social activity counter with the primary key from the database. Also notifies the appropriate model listeners. 380 * 381 * @param activityCounterId the primary key of the social activity counter 382 * @return the social activity counter that was removed 383 * @throws PortalException if a social activity counter with the primary key could not be found 384 */ 385 @Override 386 public com.liferay.portlet.social.model.SocialActivityCounter deleteSocialActivityCounter( 387 long activityCounterId) 388 throws com.liferay.portal.kernel.exception.PortalException { 389 return _socialActivityCounterLocalService.deleteSocialActivityCounter(activityCounterId); 390 } 391 392 /** 393 * Deletes the social activity counter from the database. Also notifies the appropriate model listeners. 394 * 395 * @param socialActivityCounter the social activity counter 396 * @return the social activity counter that was removed 397 */ 398 @Override 399 public com.liferay.portlet.social.model.SocialActivityCounter deleteSocialActivityCounter( 400 com.liferay.portlet.social.model.SocialActivityCounter socialActivityCounter) { 401 return _socialActivityCounterLocalService.deleteSocialActivityCounter(socialActivityCounter); 402 } 403 404 /** 405 * Disables all the counters of an asset identified by the class name and 406 * class primary key. 407 * 408 * <p> 409 * This method is used by the recycle bin to disable all counters of assets 410 * put into the recycle bin. It adjusts the owner's contribution score. 411 * </p> 412 * 413 * @param className the asset's class name 414 * @param classPK the primary key of the asset 415 * @throws PortalException if the asset owner's contribution counter could 416 not be updated 417 */ 418 @Override 419 public void disableActivityCounters(java.lang.String className, long classPK) 420 throws com.liferay.portal.kernel.exception.PortalException { 421 _socialActivityCounterLocalService.disableActivityCounters(className, 422 classPK); 423 } 424 425 /** 426 * Disables all the counters of an asset identified by the class name ID and 427 * class primary key. 428 * 429 * <p> 430 * This method is used by the recycle bin to disable all counters of assets 431 * put into the recycle bin. It adjusts the owner's contribution score. 432 * </p> 433 * 434 * @param classNameId the primary key of the asset's class 435 * @param classPK the primary key of the asset 436 * @throws PortalException if the asset owner's contribution counter could 437 not be updated 438 */ 439 @Override 440 public void disableActivityCounters(long classNameId, long classPK) 441 throws com.liferay.portal.kernel.exception.PortalException { 442 _socialActivityCounterLocalService.disableActivityCounters(classNameId, 443 classPK); 444 } 445 446 @Override 447 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 448 return _socialActivityCounterLocalService.dynamicQuery(); 449 } 450 451 /** 452 * Performs a dynamic query on the database and returns the matching rows. 453 * 454 * @param dynamicQuery the dynamic query 455 * @return the matching rows 456 */ 457 @Override 458 public <T> java.util.List<T> dynamicQuery( 459 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 460 return _socialActivityCounterLocalService.dynamicQuery(dynamicQuery); 461 } 462 463 /** 464 * Performs a dynamic query on the database and returns a range of the matching rows. 465 * 466 * <p> 467 * 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. 468 * </p> 469 * 470 * @param dynamicQuery the dynamic query 471 * @param start the lower bound of the range of model instances 472 * @param end the upper bound of the range of model instances (not inclusive) 473 * @return the range of matching rows 474 */ 475 @Override 476 public <T> java.util.List<T> dynamicQuery( 477 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 478 int end) { 479 return _socialActivityCounterLocalService.dynamicQuery(dynamicQuery, 480 start, end); 481 } 482 483 /** 484 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 485 * 486 * <p> 487 * 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. 488 * </p> 489 * 490 * @param dynamicQuery the dynamic query 491 * @param start the lower bound of the range of model instances 492 * @param end the upper bound of the range of model instances (not inclusive) 493 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 494 * @return the ordered range of matching rows 495 */ 496 @Override 497 public <T> java.util.List<T> dynamicQuery( 498 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 499 int end, 500 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 501 return _socialActivityCounterLocalService.dynamicQuery(dynamicQuery, 502 start, end, orderByComparator); 503 } 504 505 /** 506 * Returns the number of rows matching the dynamic query. 507 * 508 * @param dynamicQuery the dynamic query 509 * @return the number of rows matching the dynamic query 510 */ 511 @Override 512 public long dynamicQueryCount( 513 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 514 return _socialActivityCounterLocalService.dynamicQueryCount(dynamicQuery); 515 } 516 517 /** 518 * Returns the number of rows matching the dynamic query. 519 * 520 * @param dynamicQuery the dynamic query 521 * @param projection the projection to apply to the query 522 * @return the number of rows matching the dynamic query 523 */ 524 @Override 525 public long dynamicQueryCount( 526 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 527 com.liferay.portal.kernel.dao.orm.Projection projection) { 528 return _socialActivityCounterLocalService.dynamicQueryCount(dynamicQuery, 529 projection); 530 } 531 532 /** 533 * Enables all the counters of an asset identified by the class name and 534 * class primary key. 535 * 536 * <p> 537 * This method is used by the recycle bin to enable all counters of assets 538 * restored from the recycle bin. It adjusts the owner's contribution score. 539 * </p> 540 * 541 * @param className the asset's class name 542 * @param classPK the primary key of the asset 543 * @throws PortalException if the asset owner's contribution counter could 544 not be updated 545 */ 546 @Override 547 public void enableActivityCounters(java.lang.String className, long classPK) 548 throws com.liferay.portal.kernel.exception.PortalException { 549 _socialActivityCounterLocalService.enableActivityCounters(className, 550 classPK); 551 } 552 553 /** 554 * Enables all activity counters of an asset identified by the class name ID 555 * and class primary key. 556 * 557 * <p> 558 * This method is used by the recycle bin to enable all counters of assets 559 * restored from the recycle bin. It adjusts the owner's contribution score. 560 * </p> 561 * 562 * @param classNameId the primary key of the asset's class 563 * @param classPK the primary key of the asset 564 * @throws PortalException if the asset owner's contribution counter could 565 not be updated 566 */ 567 @Override 568 public void enableActivityCounters(long classNameId, long classPK) 569 throws com.liferay.portal.kernel.exception.PortalException { 570 _socialActivityCounterLocalService.enableActivityCounters(classNameId, 571 classPK); 572 } 573 574 /** 575 * Returns the activity counter with the given name, owner, and end period 576 * that belong to the given entity. 577 * 578 * @param groupId the primary key of the group 579 * @param classNameId the primary key of the entity's class 580 * @param classPK the primary key of the entity 581 * @param name the counter name 582 * @param ownerType the owner type 583 * @param endPeriod the end period, <code>-1</code> for the latest one 584 * @return the matching activity counter 585 */ 586 @Override 587 public com.liferay.portlet.social.model.SocialActivityCounter fetchActivityCounterByEndPeriod( 588 long groupId, long classNameId, long classPK, java.lang.String name, 589 int ownerType, int endPeriod) { 590 return _socialActivityCounterLocalService.fetchActivityCounterByEndPeriod(groupId, 591 classNameId, classPK, name, ownerType, endPeriod); 592 } 593 594 /** 595 * Returns the activity counter with the given name, owner, and start period 596 * that belong to the given entity. 597 * 598 * @param groupId the primary key of the group 599 * @param classNameId the primary key of the entity's class 600 * @param classPK the primary key of the entity 601 * @param name the counter name 602 * @param ownerType the owner type 603 * @param startPeriod the start period 604 * @return the matching activity counter 605 */ 606 @Override 607 public com.liferay.portlet.social.model.SocialActivityCounter fetchActivityCounterByStartPeriod( 608 long groupId, long classNameId, long classPK, java.lang.String name, 609 int ownerType, int startPeriod) { 610 return _socialActivityCounterLocalService.fetchActivityCounterByStartPeriod(groupId, 611 classNameId, classPK, name, ownerType, startPeriod); 612 } 613 614 /** 615 * Returns the latest activity counter with the given name and owner that 616 * belong to the given entity. 617 * 618 * @param groupId the primary key of the group 619 * @param classNameId the primary key of the entity's class 620 * @param classPK the primary key of the entity 621 * @param name the counter name 622 * @param ownerType the owner type 623 * @return the matching activity counter 624 */ 625 @Override 626 public com.liferay.portlet.social.model.SocialActivityCounter fetchLatestActivityCounter( 627 long groupId, long classNameId, long classPK, java.lang.String name, 628 int ownerType) { 629 return _socialActivityCounterLocalService.fetchLatestActivityCounter(groupId, 630 classNameId, classPK, name, ownerType); 631 } 632 633 @Override 634 public com.liferay.portlet.social.model.SocialActivityCounter fetchSocialActivityCounter( 635 long activityCounterId) { 636 return _socialActivityCounterLocalService.fetchSocialActivityCounter(activityCounterId); 637 } 638 639 @Override 640 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 641 return _socialActivityCounterLocalService.getActionableDynamicQuery(); 642 } 643 644 /** 645 * Returns the Spring bean ID for this bean. 646 * 647 * @return the Spring bean ID for this bean 648 */ 649 @Override 650 public java.lang.String getBeanIdentifier() { 651 return _socialActivityCounterLocalService.getBeanIdentifier(); 652 } 653 654 /** 655 * Returns all the activity counters with the given name and period offsets. 656 * 657 * <p> 658 * The start and end offsets can belong to different periods. This method 659 * groups the counters by name and returns the sum of their current values. 660 * </p> 661 * 662 * @param groupId the primary key of the group 663 * @param name the counter name 664 * @param startOffset the offset for the start period 665 * @param endOffset the offset for the end period 666 * @return the matching activity counters 667 */ 668 @Override 669 public java.util.List<com.liferay.portlet.social.model.SocialActivityCounter> getOffsetActivityCounters( 670 long groupId, java.lang.String name, int startOffset, int endOffset) { 671 return _socialActivityCounterLocalService.getOffsetActivityCounters(groupId, 672 name, startOffset, endOffset); 673 } 674 675 /** 676 * Returns the distribution of the activity counters with the given name and 677 * period offsets. 678 * 679 * <p> 680 * The start and end offsets can belong to different periods. This method 681 * groups the counters by their owner entity (usually some asset) and 682 * returns a counter for each entity class with the sum of the counters' 683 * current values. 684 * </p> 685 * 686 * @param groupId the primary key of the group 687 * @param name the counter name 688 * @param startOffset the offset for the start period 689 * @param endOffset the offset for the end period 690 * @return the distribution of matching activity counters 691 */ 692 @Override 693 public java.util.List<com.liferay.portlet.social.model.SocialActivityCounter> getOffsetDistributionActivityCounters( 694 long groupId, java.lang.String name, int startOffset, int endOffset) { 695 return _socialActivityCounterLocalService.getOffsetDistributionActivityCounters(groupId, 696 name, startOffset, endOffset); 697 } 698 699 /** 700 * Returns all the activity counters with the given name and time period. 701 * 702 * <p> 703 * The start and end period values can belong to different periods. This 704 * method groups the counters by name and returns the sum of their current 705 * values. 706 * </p> 707 * 708 * @param groupId the primary key of the group 709 * @param name the counter name 710 * @param startPeriod the start period 711 * @param endPeriod the end period 712 * @return the matching activity counters 713 */ 714 @Override 715 public java.util.List<com.liferay.portlet.social.model.SocialActivityCounter> getPeriodActivityCounters( 716 long groupId, java.lang.String name, int startPeriod, int endPeriod) { 717 return _socialActivityCounterLocalService.getPeriodActivityCounters(groupId, 718 name, startPeriod, endPeriod); 719 } 720 721 /** 722 * Returns the distribution of activity counters with the given name and 723 * time period. 724 * 725 * <p> 726 * The start and end period values can belong to different periods. This 727 * method groups the counters by their owner entity (usually some asset) and 728 * returns a counter for each entity class with the sum of the counters' 729 * current values. 730 * </p> 731 * 732 * @param groupId the primary key of the group 733 * @param name the counter name 734 * @param startPeriod the start period 735 * @param endPeriod the end period 736 * @return the distribution of matching activity counters 737 */ 738 @Override 739 public java.util.List<com.liferay.portlet.social.model.SocialActivityCounter> getPeriodDistributionActivityCounters( 740 long groupId, java.lang.String name, int startPeriod, int endPeriod) { 741 return _socialActivityCounterLocalService.getPeriodDistributionActivityCounters(groupId, 742 name, startPeriod, endPeriod); 743 } 744 745 @Override 746 public com.liferay.portal.model.PersistedModel getPersistedModel( 747 java.io.Serializable primaryKeyObj) 748 throws com.liferay.portal.kernel.exception.PortalException { 749 return _socialActivityCounterLocalService.getPersistedModel(primaryKeyObj); 750 } 751 752 /** 753 * Returns the social activity counter with the primary key. 754 * 755 * @param activityCounterId the primary key of the social activity counter 756 * @return the social activity counter 757 * @throws PortalException if a social activity counter with the primary key could not be found 758 */ 759 @Override 760 public com.liferay.portlet.social.model.SocialActivityCounter getSocialActivityCounter( 761 long activityCounterId) 762 throws com.liferay.portal.kernel.exception.PortalException { 763 return _socialActivityCounterLocalService.getSocialActivityCounter(activityCounterId); 764 } 765 766 /** 767 * Returns a range of all the social activity counters. 768 * 769 * <p> 770 * 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. 771 * </p> 772 * 773 * @param start the lower bound of the range of social activity counters 774 * @param end the upper bound of the range of social activity counters (not inclusive) 775 * @return the range of social activity counters 776 */ 777 @Override 778 public java.util.List<com.liferay.portlet.social.model.SocialActivityCounter> getSocialActivityCounters( 779 int start, int end) { 780 return _socialActivityCounterLocalService.getSocialActivityCounters(start, 781 end); 782 } 783 784 /** 785 * Returns the number of social activity counters. 786 * 787 * @return the number of social activity counters 788 */ 789 @Override 790 public int getSocialActivityCountersCount() { 791 return _socialActivityCounterLocalService.getSocialActivityCountersCount(); 792 } 793 794 /** 795 * Returns the range of tuples that contain users and a list of activity 796 * counters. 797 * 798 * <p> 799 * The counters returned for each user are passed to this method in the 800 * selectedNames array. The method also accepts an array of counter names 801 * that are used to rank the users. 802 * </p> 803 * 804 * <p> 805 * Useful when paginating results. Returns a maximum of <code>end - 806 * start</code> instances. <code>start</code> and <code>end</code> are not 807 * primary keys, they are indexes in the result set. Thus, <code>0</code> 808 * refers to the first result in the set. Setting both <code>start</code> 809 * and <code>end</code> to {@link 810 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 811 * result set. 812 * </p> 813 * 814 * @param groupId the primary key of the group 815 * @param rankingNames the ranking counter names 816 * @param selectedNames the counter names that will be returned with each 817 user 818 * @param start the lower bound of the range of results 819 * @param end the upper bound of the range of results (not inclusive) 820 * @return the range of matching tuples 821 */ 822 @Override 823 public java.util.List<com.liferay.portal.kernel.util.Tuple> getUserActivityCounters( 824 long groupId, java.lang.String[] rankingNames, 825 java.lang.String[] selectedNames, int start, int end) { 826 return _socialActivityCounterLocalService.getUserActivityCounters(groupId, 827 rankingNames, selectedNames, start, end); 828 } 829 830 /** 831 * Returns the number of users having a rank based on the given counters. 832 * 833 * @param groupId the primary key of the group 834 * @param rankingNames the ranking counter names 835 * @return the number of matching users 836 */ 837 @Override 838 public int getUserActivityCountersCount(long groupId, 839 java.lang.String[] rankingNames) { 840 return _socialActivityCounterLocalService.getUserActivityCountersCount(groupId, 841 rankingNames); 842 } 843 844 /** 845 * Increments the <code>user.achievements</code> counter for a user. 846 * 847 * <p> 848 * This method should be used by an external achievement class when the 849 * users unlocks an achievement. 850 * </p> 851 * 852 * @param userId the primary key of the user 853 * @param groupId the primary key of the group 854 * @throws PortalException if the group or an expected previous activity 855 counter could not be found 856 */ 857 @Override 858 public void incrementUserAchievementCounter(long userId, long groupId) 859 throws com.liferay.portal.kernel.exception.PortalException { 860 _socialActivityCounterLocalService.incrementUserAchievementCounter(userId, 861 groupId); 862 } 863 864 /** 865 * Sets the Spring bean ID for this bean. 866 * 867 * @param beanIdentifier the Spring bean ID for this bean 868 */ 869 @Override 870 public void setBeanIdentifier(java.lang.String beanIdentifier) { 871 _socialActivityCounterLocalService.setBeanIdentifier(beanIdentifier); 872 } 873 874 /** 875 * Updates the social activity counter in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 876 * 877 * @param socialActivityCounter the social activity counter 878 * @return the social activity counter that was updated 879 */ 880 @Override 881 public com.liferay.portlet.social.model.SocialActivityCounter updateSocialActivityCounter( 882 com.liferay.portlet.social.model.SocialActivityCounter socialActivityCounter) { 883 return _socialActivityCounterLocalService.updateSocialActivityCounter(socialActivityCounter); 884 } 885 886 /** 887 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 888 */ 889 @Deprecated 890 public SocialActivityCounterLocalService getWrappedSocialActivityCounterLocalService() { 891 return _socialActivityCounterLocalService; 892 } 893 894 /** 895 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 896 */ 897 @Deprecated 898 public void setWrappedSocialActivityCounterLocalService( 899 SocialActivityCounterLocalService socialActivityCounterLocalService) { 900 _socialActivityCounterLocalService = socialActivityCounterLocalService; 901 } 902 903 @Override 904 public SocialActivityCounterLocalService getWrappedService() { 905 return _socialActivityCounterLocalService; 906 } 907 908 @Override 909 public void setWrappedService( 910 SocialActivityCounterLocalService socialActivityCounterLocalService) { 911 _socialActivityCounterLocalService = socialActivityCounterLocalService; 912 } 913 914 private SocialActivityCounterLocalService _socialActivityCounterLocalService; 915 }