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 SocialActivityLocalService}. 023 * 024 * @author Brian Wing Shun Chan 025 * @see SocialActivityLocalService 026 * @generated 027 */ 028 @ProviderType 029 public class SocialActivityLocalServiceWrapper 030 implements SocialActivityLocalService, 031 ServiceWrapper<SocialActivityLocalService> { 032 public SocialActivityLocalServiceWrapper( 033 SocialActivityLocalService socialActivityLocalService) { 034 _socialActivityLocalService = socialActivityLocalService; 035 } 036 037 @Override 038 public void addActivity( 039 com.liferay.portlet.social.model.SocialActivity activity, 040 com.liferay.portlet.social.model.SocialActivity mirrorActivity) 041 throws com.liferay.portal.kernel.exception.PortalException { 042 _socialActivityLocalService.addActivity(activity, mirrorActivity); 043 } 044 045 /** 046 * Records an activity in the database, using a time based on the current 047 * time in an attempt to make the activity's time unique. 048 * 049 * @param userId the primary key of the acting user 050 * @param groupId the primary key of the group 051 * @param className the target asset's class name 052 * @param classPK the primary key of the target asset 053 * @param type the activity's type 054 * @param extraData any extra data regarding the activity 055 * @param receiverUserId the primary key of the receiving user 056 */ 057 @Override 058 public void addActivity(long userId, long groupId, 059 java.lang.String className, long classPK, int type, 060 java.lang.String extraData, long receiverUserId) 061 throws com.liferay.portal.kernel.exception.PortalException { 062 _socialActivityLocalService.addActivity(userId, groupId, className, 063 classPK, type, extraData, receiverUserId); 064 } 065 066 /** 067 * Records an activity with the given time in the database. 068 * 069 * <p> 070 * This method records a social activity done on an asset, identified by its 071 * class name and class primary key, in the database. Additional information 072 * (such as the original message ID for a reply to a forum post) is passed 073 * in via the <code>extraData</code> in JSON format. For activities 074 * affecting another user, a mirror activity is generated that describes the 075 * action from the user's point of view. The target user's ID is passed in 076 * via the <code>receiverUserId</code>. 077 * </p> 078 * 079 * <p> 080 * Example for a mirrored activity:<br> When a user replies to a message 081 * boards post, the reply action is stored in the database with the 082 * <code>receiverUserId</code> being the ID of the author of the original 083 * message. The <code>extraData</code> contains the ID of the original 084 * message in JSON format. A mirror activity is generated with the values of 085 * the <code>userId</code> and the <code>receiverUserId</code> swapped. This 086 * mirror activity basically describes a "replied to" event. 087 * </p> 088 * 089 * <p> 090 * Mirror activities are most often used in relation to friend requests and 091 * activities. 092 * </p> 093 * 094 * @param userId the primary key of the acting user 095 * @param groupId the primary key of the group 096 * @param createDate the activity's date 097 * @param className the target asset's class name 098 * @param classPK the primary key of the target asset 099 * @param type the activity's type 100 * @param extraData any extra data regarding the activity 101 * @param receiverUserId the primary key of the receiving user 102 */ 103 @Override 104 public void addActivity(long userId, long groupId, 105 java.util.Date createDate, java.lang.String className, long classPK, 106 int type, java.lang.String extraData, long receiverUserId) 107 throws com.liferay.portal.kernel.exception.PortalException { 108 _socialActivityLocalService.addActivity(userId, groupId, createDate, 109 className, classPK, type, extraData, receiverUserId); 110 } 111 112 /** 113 * Adds the social activity to the database. Also notifies the appropriate model listeners. 114 * 115 * @param socialActivity the social activity 116 * @return the social activity that was added 117 */ 118 @Override 119 public com.liferay.portlet.social.model.SocialActivity addSocialActivity( 120 com.liferay.portlet.social.model.SocialActivity socialActivity) { 121 return _socialActivityLocalService.addSocialActivity(socialActivity); 122 } 123 124 /** 125 * Records an activity with the current time in the database, but only if 126 * there isn't one with the same parameters. 127 * 128 * <p> 129 * For the main functionality see {@link #addActivity(long, long, Date, 130 * String, long, int, String, long)} 131 * </p> 132 * 133 * @param userId the primary key of the acting user 134 * @param groupId the primary key of the group 135 * @param className the target asset's class name 136 * @param classPK the primary key of the target asset 137 * @param type the activity's type 138 * @param extraData any extra data regarding the activity 139 * @param receiverUserId the primary key of the receiving user 140 */ 141 @Override 142 public void addUniqueActivity(long userId, long groupId, 143 java.lang.String className, long classPK, int type, 144 java.lang.String extraData, long receiverUserId) 145 throws com.liferay.portal.kernel.exception.PortalException { 146 _socialActivityLocalService.addUniqueActivity(userId, groupId, 147 className, classPK, type, extraData, receiverUserId); 148 } 149 150 /** 151 * Records an activity in the database, but only if there isn't already an 152 * activity with the same parameters. 153 * 154 * <p> 155 * For the main functionality see {@link #addActivity(long, long, Date, 156 * String, long, int, String, long)} 157 * </p> 158 * 159 * @param userId the primary key of the acting user 160 * @param groupId the primary key of the group 161 * @param createDate the activity's date 162 * @param className the target asset's class name 163 * @param classPK the primary key of the target asset 164 * @param type the activity's type 165 * @param extraData any extra data regarding the activity 166 * @param receiverUserId the primary key of the receiving user 167 */ 168 @Override 169 public void addUniqueActivity(long userId, long groupId, 170 java.util.Date createDate, java.lang.String className, long classPK, 171 int type, java.lang.String extraData, long receiverUserId) 172 throws com.liferay.portal.kernel.exception.PortalException { 173 _socialActivityLocalService.addUniqueActivity(userId, groupId, 174 createDate, className, classPK, type, extraData, receiverUserId); 175 } 176 177 /** 178 * Creates a new social activity with the primary key. Does not add the social activity to the database. 179 * 180 * @param activityId the primary key for the new social activity 181 * @return the new social activity 182 */ 183 @Override 184 public com.liferay.portlet.social.model.SocialActivity createSocialActivity( 185 long activityId) { 186 return _socialActivityLocalService.createSocialActivity(activityId); 187 } 188 189 /** 190 * Removes stored activities for the asset. 191 * 192 * @param assetEntry the asset from which to remove stored activities 193 */ 194 @Override 195 public void deleteActivities( 196 com.liferay.portlet.asset.model.AssetEntry assetEntry) 197 throws com.liferay.portal.kernel.exception.PortalException { 198 _socialActivityLocalService.deleteActivities(assetEntry); 199 } 200 201 /** 202 * Removes stored activities for the asset identified by the class name and 203 * class primary key. 204 * 205 * @param className the target asset's class name 206 * @param classPK the primary key of the target asset 207 */ 208 @Override 209 public void deleteActivities(java.lang.String className, long classPK) 210 throws com.liferay.portal.kernel.exception.PortalException { 211 _socialActivityLocalService.deleteActivities(className, classPK); 212 } 213 214 @Override 215 public void deleteActivities(long groupId) { 216 _socialActivityLocalService.deleteActivities(groupId); 217 } 218 219 /** 220 * Removes the stored activity and its mirror activity from the database. 221 * 222 * @param activity the activity to be removed 223 */ 224 @Override 225 public void deleteActivity( 226 com.liferay.portlet.social.model.SocialActivity activity) 227 throws com.liferay.portal.kernel.exception.PortalException { 228 _socialActivityLocalService.deleteActivity(activity); 229 } 230 231 /** 232 * Removes the stored activity from the database. 233 * 234 * @param activityId the primary key of the stored activity 235 */ 236 @Override 237 public void deleteActivity(long activityId) 238 throws com.liferay.portal.kernel.exception.PortalException { 239 _socialActivityLocalService.deleteActivity(activityId); 240 } 241 242 /** 243 * @throws PortalException 244 */ 245 @Override 246 public com.liferay.portal.model.PersistedModel deletePersistedModel( 247 com.liferay.portal.model.PersistedModel persistedModel) 248 throws com.liferay.portal.kernel.exception.PortalException { 249 return _socialActivityLocalService.deletePersistedModel(persistedModel); 250 } 251 252 /** 253 * Deletes the social activity with the primary key from the database. Also notifies the appropriate model listeners. 254 * 255 * @param activityId the primary key of the social activity 256 * @return the social activity that was removed 257 * @throws PortalException if a social activity with the primary key could not be found 258 */ 259 @Override 260 public com.liferay.portlet.social.model.SocialActivity deleteSocialActivity( 261 long activityId) 262 throws com.liferay.portal.kernel.exception.PortalException { 263 return _socialActivityLocalService.deleteSocialActivity(activityId); 264 } 265 266 /** 267 * Deletes the social activity from the database. Also notifies the appropriate model listeners. 268 * 269 * @param socialActivity the social activity 270 * @return the social activity that was removed 271 */ 272 @Override 273 public com.liferay.portlet.social.model.SocialActivity deleteSocialActivity( 274 com.liferay.portlet.social.model.SocialActivity socialActivity) { 275 return _socialActivityLocalService.deleteSocialActivity(socialActivity); 276 } 277 278 /** 279 * Removes the user's stored activities from the database. 280 * 281 * <p> 282 * This method removes all activities where the user is either the actor or 283 * the receiver. 284 * </p> 285 * 286 * @param userId the primary key of the user 287 */ 288 @Override 289 public void deleteUserActivities(long userId) 290 throws com.liferay.portal.kernel.exception.PortalException { 291 _socialActivityLocalService.deleteUserActivities(userId); 292 } 293 294 @Override 295 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 296 return _socialActivityLocalService.dynamicQuery(); 297 } 298 299 /** 300 * Performs a dynamic query on the database and returns the matching rows. 301 * 302 * @param dynamicQuery the dynamic query 303 * @return the matching rows 304 */ 305 @Override 306 public <T> java.util.List<T> dynamicQuery( 307 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 308 return _socialActivityLocalService.dynamicQuery(dynamicQuery); 309 } 310 311 /** 312 * Performs a dynamic query on the database and returns a range of the matching rows. 313 * 314 * <p> 315 * 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.SocialActivityModelImpl}. 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. 316 * </p> 317 * 318 * @param dynamicQuery the dynamic query 319 * @param start the lower bound of the range of model instances 320 * @param end the upper bound of the range of model instances (not inclusive) 321 * @return the range of matching rows 322 */ 323 @Override 324 public <T> java.util.List<T> dynamicQuery( 325 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 326 int end) { 327 return _socialActivityLocalService.dynamicQuery(dynamicQuery, start, end); 328 } 329 330 /** 331 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 332 * 333 * <p> 334 * 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.SocialActivityModelImpl}. 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. 335 * </p> 336 * 337 * @param dynamicQuery the dynamic query 338 * @param start the lower bound of the range of model instances 339 * @param end the upper bound of the range of model instances (not inclusive) 340 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 341 * @return the ordered range of matching rows 342 */ 343 @Override 344 public <T> java.util.List<T> dynamicQuery( 345 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 346 int end, 347 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 348 return _socialActivityLocalService.dynamicQuery(dynamicQuery, start, 349 end, orderByComparator); 350 } 351 352 /** 353 * Returns the number of rows matching the dynamic query. 354 * 355 * @param dynamicQuery the dynamic query 356 * @return the number of rows matching the dynamic query 357 */ 358 @Override 359 public long dynamicQueryCount( 360 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 361 return _socialActivityLocalService.dynamicQueryCount(dynamicQuery); 362 } 363 364 /** 365 * Returns the number of rows matching the dynamic query. 366 * 367 * @param dynamicQuery the dynamic query 368 * @param projection the projection to apply to the query 369 * @return the number of rows matching the dynamic query 370 */ 371 @Override 372 public long dynamicQueryCount( 373 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 374 com.liferay.portal.kernel.dao.orm.Projection projection) { 375 return _socialActivityLocalService.dynamicQueryCount(dynamicQuery, 376 projection); 377 } 378 379 @Override 380 public com.liferay.portlet.social.model.SocialActivity fetchFirstActivity( 381 java.lang.String className, long classPK, int type) { 382 return _socialActivityLocalService.fetchFirstActivity(className, 383 classPK, type); 384 } 385 386 @Override 387 public com.liferay.portlet.social.model.SocialActivity fetchSocialActivity( 388 long activityId) { 389 return _socialActivityLocalService.fetchSocialActivity(activityId); 390 } 391 392 @Override 393 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 394 return _socialActivityLocalService.getActionableDynamicQuery(); 395 } 396 397 /** 398 * Returns a range of all the activities done on assets identified by the 399 * class name. 400 * 401 * <p> 402 * Useful when paginating results. Returns a maximum of <code>end - 403 * start</code> instances. <code>start</code> and <code>end</code> are not 404 * primary keys, they are indexes in the result set. Thus, <code>0</code> 405 * refers to the first result in the set. Setting both <code>start</code> 406 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 407 * result set. 408 * </p> 409 * 410 * @param className the target asset's class name 411 * @param start the lower bound of the range of results 412 * @param end the upper bound of the range of results (not inclusive) 413 * @return the range of matching activities 414 */ 415 @Override 416 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getActivities( 417 java.lang.String className, int start, int end) { 418 return _socialActivityLocalService.getActivities(className, start, end); 419 } 420 421 /** 422 * Returns a range of all the activities done on assets identified by the 423 * class name ID. 424 * 425 * <p> 426 * Useful when paginating results. Returns a maximum of <code>end - 427 * start</code> instances. <code>start</code> and <code>end</code> are not 428 * primary keys, they are indexes in the result set. Thus, <code>0</code> 429 * refers to the first result in the set. Setting both <code>start</code> 430 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 431 * result set. 432 * </p> 433 * 434 * @param classNameId the target asset's class name ID 435 * @param start the lower bound of the range of results 436 * @param end the upper bound of the range of results (not inclusive) 437 * @return the range of matching activities 438 */ 439 @Override 440 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getActivities( 441 long classNameId, int start, int end) { 442 return _socialActivityLocalService.getActivities(classNameId, start, end); 443 } 444 445 /** 446 * Returns a range of all the activities done on the asset identified by the 447 * class name and the class primary key that are mirrors of the activity 448 * identified by the mirror activity ID. 449 * 450 * <p> 451 * Useful when paginating results. Returns a maximum of <code>end - 452 * start</code> instances. <code>start</code> and <code>end</code> are not 453 * primary keys, they are indexes in the result set. Thus, <code>0</code> 454 * refers to the first result in the set. Setting both <code>start</code> 455 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 456 * result set. 457 * </p> 458 * 459 * @param mirrorActivityId the primary key of the mirror activity 460 * @param className the target asset's class name 461 * @param classPK the primary key of the target asset 462 * @param start the lower bound of the range of results 463 * @param end the upper bound of the range of results (not inclusive) 464 * @return the range of matching activities 465 */ 466 @Override 467 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getActivities( 468 long mirrorActivityId, java.lang.String className, long classPK, 469 int start, int end) { 470 return _socialActivityLocalService.getActivities(mirrorActivityId, 471 className, classPK, start, end); 472 } 473 474 /** 475 * Returns a range of all the activities done on the asset identified by the 476 * class name ID and class primary key that are mirrors of the activity 477 * identified by the mirror activity ID. 478 * 479 * <p> 480 * Useful when paginating results. Returns a maximum of <code>end - 481 * start</code> instances. <code>start</code> and <code>end</code> are not 482 * primary keys, they are indexes in the result set. Thus, <code>0</code> 483 * refers to the first result in the set. Setting both <code>start</code> 484 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 485 * result set. 486 * </p> 487 * 488 * @param mirrorActivityId the primary key of the mirror activity 489 * @param classNameId the target asset's class name ID 490 * @param classPK the primary key of the target asset 491 * @param start the lower bound of the range of results 492 * @param end the upper bound of the range of results (not inclusive) 493 * @return the range of matching activities 494 */ 495 @Override 496 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getActivities( 497 long mirrorActivityId, long classNameId, long classPK, int start, 498 int end) { 499 return _socialActivityLocalService.getActivities(mirrorActivityId, 500 classNameId, classPK, start, end); 501 } 502 503 /** 504 * Returns the number of activities done on assets identified by class name. 505 * 506 * @param className the target asset's class name 507 * @return the number of matching activities 508 */ 509 @Override 510 public int getActivitiesCount(java.lang.String className) { 511 return _socialActivityLocalService.getActivitiesCount(className); 512 } 513 514 /** 515 * Returns the number of activities done on assets identified by the class 516 * name ID. 517 * 518 * @param classNameId the target asset's class name ID 519 * @return the number of matching activities 520 */ 521 @Override 522 public int getActivitiesCount(long classNameId) { 523 return _socialActivityLocalService.getActivitiesCount(classNameId); 524 } 525 526 /** 527 * Returns the number of activities done on the asset identified by the 528 * class name and class primary key that are mirrors of the activity 529 * identified by the mirror activity ID. 530 * 531 * @param mirrorActivityId the primary key of the mirror activity 532 * @param className the target asset's class name 533 * @param classPK the primary key of the target asset 534 * @return the number of matching activities 535 */ 536 @Override 537 public int getActivitiesCount(long mirrorActivityId, 538 java.lang.String className, long classPK) { 539 return _socialActivityLocalService.getActivitiesCount(mirrorActivityId, 540 className, classPK); 541 } 542 543 /** 544 * Returns the number of activities done on the asset identified by the 545 * class name ID and class primary key that are mirrors of the activity 546 * identified by the mirror activity ID. 547 * 548 * @param mirrorActivityId the primary key of the mirror activity 549 * @param classNameId the target asset's class name ID 550 * @param classPK the primary key of the target asset 551 * @return the number of matching activities 552 */ 553 @Override 554 public int getActivitiesCount(long mirrorActivityId, long classNameId, 555 long classPK) { 556 return _socialActivityLocalService.getActivitiesCount(mirrorActivityId, 557 classNameId, classPK); 558 } 559 560 /** 561 * Returns the activity identified by its primary key. 562 * 563 * @param activityId the primary key of the activity 564 * @return Returns the activity 565 */ 566 @Override 567 public com.liferay.portlet.social.model.SocialActivity getActivity( 568 long activityId) 569 throws com.liferay.portal.kernel.exception.PortalException { 570 return _socialActivityLocalService.getActivity(activityId); 571 } 572 573 @Override 574 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getActivitySetActivities( 575 long activitySetId, int start, int end) { 576 return _socialActivityLocalService.getActivitySetActivities(activitySetId, 577 start, end); 578 } 579 580 /** 581 * Returns a range of all the activities done in the group. 582 * 583 * <p> 584 * This method only finds activities without mirrors. 585 * </p> 586 * 587 * <p> 588 * Useful when paginating results. Returns a maximum of <code>end - 589 * start</code> instances. <code>start</code> and <code>end</code> are not 590 * primary keys, they are indexes in the result set. Thus, <code>0</code> 591 * refers to the first result in the set. Setting both <code>start</code> 592 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 593 * result set. 594 * </p> 595 * 596 * @param groupId the primary key of the group 597 * @param start the lower bound of the range of results 598 * @param end the upper bound of the range of results (not inclusive) 599 * @return the range of matching activities 600 */ 601 @Override 602 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getGroupActivities( 603 long groupId, int start, int end) { 604 return _socialActivityLocalService.getGroupActivities(groupId, start, 605 end); 606 } 607 608 /** 609 * Returns the number of activities done in the group. 610 * 611 * <p> 612 * This method only counts activities without mirrors. 613 * </p> 614 * 615 * @param groupId the primary key of the group 616 * @return the number of matching activities 617 */ 618 @Override 619 public int getGroupActivitiesCount(long groupId) { 620 return _socialActivityLocalService.getGroupActivitiesCount(groupId); 621 } 622 623 /** 624 * Returns a range of activities done by users that are members of the 625 * group. 626 * 627 * <p> 628 * This method only finds activities without mirrors. 629 * </p> 630 * 631 * <p> 632 * Useful when paginating results. Returns a maximum of <code>end - 633 * start</code> instances. <code>start</code> and <code>end</code> are not 634 * primary keys, they are indexes in the result set. Thus, <code>0</code> 635 * refers to the first result in the set. Setting both <code>start</code> 636 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 637 * result set. 638 * </p> 639 * 640 * @param groupId the primary key of the group 641 * @param start the lower bound of the range of results 642 * @param end the upper bound of the range of results (not inclusive) 643 * @return the range of matching activities 644 */ 645 @Override 646 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getGroupUsersActivities( 647 long groupId, int start, int end) { 648 return _socialActivityLocalService.getGroupUsersActivities(groupId, 649 start, end); 650 } 651 652 /** 653 * Returns the number of activities done by users that are members of the 654 * group. 655 * 656 * <p> 657 * This method only counts activities without mirrors. 658 * </p> 659 * 660 * @param groupId the primary key of the group 661 * @return the number of matching activities 662 */ 663 @Override 664 public int getGroupUsersActivitiesCount(long groupId) { 665 return _socialActivityLocalService.getGroupUsersActivitiesCount(groupId); 666 } 667 668 @Override 669 public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() { 670 return _socialActivityLocalService.getIndexableActionableDynamicQuery(); 671 } 672 673 /** 674 * Returns the activity that has the mirror activity. 675 * 676 * @param mirrorActivityId the primary key of the mirror activity 677 * @return Returns the mirror activity 678 */ 679 @Override 680 public com.liferay.portlet.social.model.SocialActivity getMirrorActivity( 681 long mirrorActivityId) 682 throws com.liferay.portal.kernel.exception.PortalException { 683 return _socialActivityLocalService.getMirrorActivity(mirrorActivityId); 684 } 685 686 /** 687 * Returns the OSGi service identifier. 688 * 689 * @return the OSGi service identifier 690 */ 691 @Override 692 public java.lang.String getOSGiServiceIdentifier() { 693 return _socialActivityLocalService.getOSGiServiceIdentifier(); 694 } 695 696 /** 697 * Returns a range of all the activities done in the organization. This 698 * method only finds activities without mirrors. 699 * 700 * <p> 701 * Useful when paginating results. Returns a maximum of <code>end - 702 * start</code> instances. <code>start</code> and <code>end</code> are not 703 * primary keys, they are indexes in the result set. Thus, <code>0</code> 704 * refers to the first result in the set. Setting both <code>start</code> 705 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 706 * result set. 707 * </p> 708 * 709 * @param organizationId the primary key of the organization 710 * @param start the lower bound of the range of results 711 * @param end the upper bound of the range of results (not inclusive) 712 * @return the range of matching activities 713 */ 714 @Override 715 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getOrganizationActivities( 716 long organizationId, int start, int end) { 717 return _socialActivityLocalService.getOrganizationActivities(organizationId, 718 start, end); 719 } 720 721 /** 722 * Returns the number of activities done in the organization. This method 723 * only counts activities without mirrors. 724 * 725 * @param organizationId the primary key of the organization 726 * @return the number of matching activities 727 */ 728 @Override 729 public int getOrganizationActivitiesCount(long organizationId) { 730 return _socialActivityLocalService.getOrganizationActivitiesCount(organizationId); 731 } 732 733 /** 734 * Returns a range of all the activities done by users of the organization. 735 * This method only finds activities without mirrors. 736 * 737 * <p> 738 * Useful when paginating results. Returns a maximum of <code>end - 739 * start</code> instances. <code>start</code> and <code>end</code> are not 740 * primary keys, they are indexes in the result set. Thus, <code>0</code> 741 * refers to the first result in the set. Setting both <code>start</code> 742 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 743 * result set. 744 * </p> 745 * 746 * @param organizationId the primary key of the organization 747 * @param start the lower bound of the range of results 748 * @param end the upper bound of the range of results (not inclusive) 749 * @return the range of matching activities 750 */ 751 @Override 752 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getOrganizationUsersActivities( 753 long organizationId, int start, int end) { 754 return _socialActivityLocalService.getOrganizationUsersActivities(organizationId, 755 start, end); 756 } 757 758 /** 759 * Returns the number of activities done by users of the organization. This 760 * method only counts activities without mirrors. 761 * 762 * @param organizationId the primary key of the organization 763 * @return the number of matching activities 764 */ 765 @Override 766 public int getOrganizationUsersActivitiesCount(long organizationId) { 767 return _socialActivityLocalService.getOrganizationUsersActivitiesCount(organizationId); 768 } 769 770 @Override 771 public com.liferay.portal.model.PersistedModel getPersistedModel( 772 java.io.Serializable primaryKeyObj) 773 throws com.liferay.portal.kernel.exception.PortalException { 774 return _socialActivityLocalService.getPersistedModel(primaryKeyObj); 775 } 776 777 /** 778 * Returns a range of all the activities done by users in a relationship 779 * with the user identified by the user ID. 780 * 781 * <p> 782 * Useful when paginating results. Returns a maximum of <code>end - 783 * start</code> instances. <code>start</code> and <code>end</code> are not 784 * primary keys, they are indexes in the result set. Thus, <>0</code> refers 785 * to the first result in the set. Setting both <code>start</code> and 786 * <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result 787 * set. 788 * </p> 789 * 790 * @param userId the primary key of the user 791 * @param start the lower bound of the range of results 792 * @param end the upper bound of the range of results (not inclusive) 793 * @return the range of matching activities 794 */ 795 @Override 796 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getRelationActivities( 797 long userId, int start, int end) { 798 return _socialActivityLocalService.getRelationActivities(userId, start, 799 end); 800 } 801 802 /** 803 * Returns a range of all the activities done by users in a relationship of 804 * type <code>type</code> with the user identified by <code>userId</code>. 805 * This method only finds activities without mirrors. 806 * 807 * <p> 808 * Useful when paginating results. Returns a maximum of <code>end - 809 * start</code> instances. <code>start</code> and <code>end</code> are not 810 * primary keys, they are indexes in the result set. Thus, <code>0</code> 811 * refers to the first result in the set. Setting both <code>start</code> 812 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 813 * result set. 814 * </p> 815 * 816 * @param userId the primary key of the user 817 * @param type the relationship type 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 activities 821 */ 822 @Override 823 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getRelationActivities( 824 long userId, int type, int start, int end) { 825 return _socialActivityLocalService.getRelationActivities(userId, type, 826 start, end); 827 } 828 829 /** 830 * Returns the number of activities done by users in a relationship with the 831 * user identified by userId. 832 * 833 * @param userId the primary key of the user 834 * @return the number of matching activities 835 */ 836 @Override 837 public int getRelationActivitiesCount(long userId) { 838 return _socialActivityLocalService.getRelationActivitiesCount(userId); 839 } 840 841 /** 842 * Returns the number of activities done by users in a relationship of type 843 * <code>type</code> with the user identified by <code>userId</code>. This 844 * method only counts activities without mirrors. 845 * 846 * @param userId the primary key of the user 847 * @param type the relationship type 848 * @return the number of matching activities 849 */ 850 @Override 851 public int getRelationActivitiesCount(long userId, int type) { 852 return _socialActivityLocalService.getRelationActivitiesCount(userId, 853 type); 854 } 855 856 /** 857 * Returns a range of all the social activities. 858 * 859 * <p> 860 * 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.SocialActivityModelImpl}. 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. 861 * </p> 862 * 863 * @param start the lower bound of the range of social activities 864 * @param end the upper bound of the range of social activities (not inclusive) 865 * @return the range of social activities 866 */ 867 @Override 868 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getSocialActivities( 869 int start, int end) { 870 return _socialActivityLocalService.getSocialActivities(start, end); 871 } 872 873 /** 874 * Returns the number of social activities. 875 * 876 * @return the number of social activities 877 */ 878 @Override 879 public int getSocialActivitiesCount() { 880 return _socialActivityLocalService.getSocialActivitiesCount(); 881 } 882 883 /** 884 * Returns the social activity with the primary key. 885 * 886 * @param activityId the primary key of the social activity 887 * @return the social activity 888 * @throws PortalException if a social activity with the primary key could not be found 889 */ 890 @Override 891 public com.liferay.portlet.social.model.SocialActivity getSocialActivity( 892 long activityId) 893 throws com.liferay.portal.kernel.exception.PortalException { 894 return _socialActivityLocalService.getSocialActivity(activityId); 895 } 896 897 /** 898 * Returns a range of all the activities done by the user. 899 * 900 * <p> 901 * Useful when paginating results. Returns a maximum of <code>end - 902 * start</code> instances. <code>start</code> and <code>end</code> are not 903 * primary keys, they are indexes in the result set. Thus, <code>0</code> 904 * refers to the first result in the set. Setting both <code>start</code> 905 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 906 * result set. 907 * </p> 908 * 909 * @param userId the primary key of the user 910 * @param start the lower bound of the range of results 911 * @param end the upper bound of the range of results (not inclusive) 912 * @return the range of matching activities 913 */ 914 @Override 915 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getUserActivities( 916 long userId, int start, int end) { 917 return _socialActivityLocalService.getUserActivities(userId, start, end); 918 } 919 920 /** 921 * Returns the number of activities done by the user. 922 * 923 * @param userId the primary key of the user 924 * @return the number of matching activities 925 */ 926 @Override 927 public int getUserActivitiesCount(long userId) { 928 return _socialActivityLocalService.getUserActivitiesCount(userId); 929 } 930 931 /** 932 * Returns a range of all the activities done in the user's groups. This 933 * method only finds activities without mirrors. 934 * 935 * <p> 936 * Useful when paginating results. Returns a maximum of <code>end - 937 * start</code> instances. <code>start</code> and <code>end</code> are not 938 * primary keys, they are indexes in the result set. Thus, <code>0</code> 939 * refers to the first result in the set. Setting both <code>start</code> 940 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 941 * result set. 942 * </p> 943 * 944 * @param userId the primary key of the user 945 * @param start the lower bound of the range of results 946 * @param end the upper bound of the range of results (not inclusive) 947 * @return the range of matching activities 948 */ 949 @Override 950 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getUserGroupsActivities( 951 long userId, int start, int end) { 952 return _socialActivityLocalService.getUserGroupsActivities(userId, 953 start, end); 954 } 955 956 /** 957 * Returns the number of activities done in user's groups. This method only 958 * counts activities without mirrors. 959 * 960 * @param userId the primary key of the user 961 * @return the number of matching activities 962 */ 963 @Override 964 public int getUserGroupsActivitiesCount(long userId) { 965 return _socialActivityLocalService.getUserGroupsActivitiesCount(userId); 966 } 967 968 /** 969 * Returns a range of all the activities done in the user's groups and 970 * organizations. This method only finds activities without mirrors. 971 * 972 * <p> 973 * Useful when paginating results. Returns a maximum of <code>end - 974 * start</code> instances. <code>start</code> and <code>end</code> are not 975 * primary keys, they are indexes in the result set. Thus, <code>0</code> 976 * refers to the first result in the set. Setting both <code>start</code> 977 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 978 * result set. 979 * </p> 980 * 981 * @param userId the primary key of the user 982 * @param start the lower bound of the range of results 983 * @param end the upper bound of the range of results (not inclusive) 984 * @return the range of matching activities 985 */ 986 @Override 987 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getUserGroupsAndOrganizationsActivities( 988 long userId, int start, int end) { 989 return _socialActivityLocalService.getUserGroupsAndOrganizationsActivities(userId, 990 start, end); 991 } 992 993 /** 994 * Returns the number of activities done in user's groups and organizations. 995 * This method only counts activities without mirrors. 996 * 997 * @param userId the primary key of the user 998 * @return the number of matching activities 999 */ 1000 @Override 1001 public int getUserGroupsAndOrganizationsActivitiesCount(long userId) { 1002 return _socialActivityLocalService.getUserGroupsAndOrganizationsActivitiesCount(userId); 1003 } 1004 1005 /** 1006 * Returns a range of all activities done in the user's organizations. This 1007 * method only finds activities without mirrors. 1008 * 1009 * <p> 1010 * Useful when paginating results. Returns a maximum of <code>end - 1011 * start</code> instances. <code>start</code> and <code>end</code> are not 1012 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1013 * refers to the first result in the set. Setting both <code>start</code> 1014 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1015 * result set. 1016 * </p> 1017 * 1018 * @param userId the primary key of the user 1019 * @param start the lower bound of the range of results 1020 * @param end the upper bound of the range of results (not inclusive) 1021 * @return the range of matching activities 1022 */ 1023 @Override 1024 public java.util.List<com.liferay.portlet.social.model.SocialActivity> getUserOrganizationsActivities( 1025 long userId, int start, int end) { 1026 return _socialActivityLocalService.getUserOrganizationsActivities(userId, 1027 start, end); 1028 } 1029 1030 /** 1031 * Returns the number of activities done in the user's organizations. This 1032 * method only counts activities without mirrors. 1033 * 1034 * @param userId the primary key of the user 1035 * @return the number of matching activities 1036 */ 1037 @Override 1038 public int getUserOrganizationsActivitiesCount(long userId) { 1039 return _socialActivityLocalService.getUserOrganizationsActivitiesCount(userId); 1040 } 1041 1042 /** 1043 * Updates the social activity in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 1044 * 1045 * @param socialActivity the social activity 1046 * @return the social activity that was updated 1047 */ 1048 @Override 1049 public com.liferay.portlet.social.model.SocialActivity updateSocialActivity( 1050 com.liferay.portlet.social.model.SocialActivity socialActivity) { 1051 return _socialActivityLocalService.updateSocialActivity(socialActivity); 1052 } 1053 1054 @Override 1055 public SocialActivityLocalService getWrappedService() { 1056 return _socialActivityLocalService; 1057 } 1058 1059 @Override 1060 public void setWrappedService( 1061 SocialActivityLocalService socialActivityLocalService) { 1062 _socialActivityLocalService = socialActivityLocalService; 1063 } 1064 1065 private SocialActivityLocalService _socialActivityLocalService; 1066 }