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.http; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.log.Log; 020 import com.liferay.portal.kernel.log.LogFactoryUtil; 021 022 import com.liferay.portlet.social.service.SocialActivityServiceUtil; 023 024 import java.rmi.RemoteException; 025 026 /** 027 * Provides the SOAP utility for the 028 * {@link SocialActivityServiceUtil} service utility. The 029 * static methods of this class calls the same methods of the service utility. 030 * However, the signatures are different because it is difficult for SOAP to 031 * support certain types. 032 * 033 * <p> 034 * ServiceBuilder follows certain rules in translating the methods. For example, 035 * if the method in the service utility returns a {@link java.util.List}, that 036 * is translated to an array of {@link com.liferay.portlet.social.model.SocialActivitySoap}. 037 * If the method in the service utility returns a 038 * {@link com.liferay.portlet.social.model.SocialActivity}, that is translated to a 039 * {@link com.liferay.portlet.social.model.SocialActivitySoap}. Methods that SOAP cannot 040 * safely wire are skipped. 041 * </p> 042 * 043 * <p> 044 * The benefits of using the SOAP utility is that it is cross platform 045 * compatible. SOAP allows different languages like Java, .NET, C++, PHP, and 046 * even Perl, to call the generated services. One drawback of SOAP is that it is 047 * slow because it needs to serialize all calls into a text format (XML). 048 * </p> 049 * 050 * <p> 051 * You can see a list of services at http://localhost:8080/api/axis. Set the 052 * property <b>axis.servlet.hosts.allowed</b> in portal.properties to configure 053 * security. 054 * </p> 055 * 056 * <p> 057 * The SOAP utility is only generated for remote services. 058 * </p> 059 * 060 * @author Brian Wing Shun Chan 061 * @see SocialActivityServiceHttp 062 * @see com.liferay.portlet.social.model.SocialActivitySoap 063 * @see SocialActivityServiceUtil 064 * @generated 065 */ 066 @ProviderType 067 public class SocialActivityServiceSoap { 068 /** 069 * Returns a range of all the activities done on assets identified by the 070 * class name ID. 071 * 072 * <p> 073 * Useful when paginating results. Returns a maximum of <code>end - 074 * start</code> instances. <code>start</code> and <code>end</code> are not 075 * primary keys, they are indexes in the result set. Thus, <code>0</code> 076 * refers to the first result in the set. Setting both <code>start</code> 077 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 078 * result set. 079 * </p> 080 * 081 * @param classNameId the target asset's class name ID 082 * @param start the lower bound of the range of results 083 * @param end the upper bound of the range of results (not inclusive) 084 * @return the range of matching activities 085 * @throws PortalException if a permission checker was not initialized 086 */ 087 public static com.liferay.portlet.social.model.SocialActivitySoap[] getActivities( 088 long classNameId, int start, int end) throws RemoteException { 089 try { 090 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 091 SocialActivityServiceUtil.getActivities(classNameId, start, end); 092 093 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 094 } 095 catch (Exception e) { 096 _log.error(e, e); 097 098 throw new RemoteException(e.getMessage()); 099 } 100 } 101 102 /** 103 * Returns a range of all the activities done on the asset identified by the 104 * class name ID and class primary key that are mirrors of the activity 105 * identified by the mirror activity ID. 106 * 107 * <p> 108 * Useful when paginating results. Returns a maximum of <code>end - 109 * start</code> instances. <code>start</code> and <code>end</code> are not 110 * primary keys, they are indexes in the result set. Thus, <code>0</code> 111 * refers to the first result in the set. Setting both <code>start</code> 112 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 113 * result set. 114 * </p> 115 * 116 * @param mirrorActivityId the primary key of the mirror activity 117 * @param classNameId the target asset's class name ID 118 * @param classPK the primary key of the target asset 119 * @param start the lower bound of the range of results 120 * @param end the upper bound of the range of results (not inclusive) 121 * @return the range of matching activities 122 * @throws PortalException if a permission checker was not initialized 123 */ 124 public static com.liferay.portlet.social.model.SocialActivitySoap[] getActivities( 125 long mirrorActivityId, long classNameId, long classPK, int start, 126 int end) throws RemoteException { 127 try { 128 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 129 SocialActivityServiceUtil.getActivities(mirrorActivityId, 130 classNameId, classPK, start, end); 131 132 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 133 } 134 catch (Exception e) { 135 _log.error(e, e); 136 137 throw new RemoteException(e.getMessage()); 138 } 139 } 140 141 /** 142 * Returns a range of all the activities done on the asset identified by the 143 * class name and the class primary key that are mirrors of the activity 144 * identified by the mirror activity ID. 145 * 146 * <p> 147 * Useful when paginating results. Returns a maximum of <code>end - 148 * start</code> instances. <code>start</code> and <code>end</code> are not 149 * primary keys, they are indexes in the result set. Thus, <code>0</code> 150 * refers to the first result in the set. Setting both <code>start</code> 151 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 152 * result set. 153 * </p> 154 * 155 * @param mirrorActivityId the primary key of the mirror activity 156 * @param className the target asset's class name 157 * @param classPK the primary key of the target asset 158 * @param start the lower bound of the range of results 159 * @param end the upper bound of the range of results (not inclusive) 160 * @return the range of matching activities 161 * @throws PortalException if a permission checker was not initialized 162 */ 163 public static com.liferay.portlet.social.model.SocialActivitySoap[] getActivities( 164 long mirrorActivityId, java.lang.String className, long classPK, 165 int start, int end) throws RemoteException { 166 try { 167 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 168 SocialActivityServiceUtil.getActivities(mirrorActivityId, 169 className, classPK, start, end); 170 171 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 172 } 173 catch (Exception e) { 174 _log.error(e, e); 175 176 throw new RemoteException(e.getMessage()); 177 } 178 } 179 180 /** 181 * Returns a range of all the activities done on assets identified by the 182 * class name. 183 * 184 * <p> 185 * Useful when paginating results. Returns a maximum of <code>end - 186 * start</code> instances. <code>start</code> and <code>end</code> are not 187 * primary keys, they are indexes in the result set. Thus, <code>0</code> 188 * refers to the first result in the set. Setting both <code>start</code> 189 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 190 * result set. 191 * </p> 192 * 193 * @param className the target asset's class name 194 * @param start the lower bound of the range of results 195 * @param end the upper bound of the range of results (not inclusive) 196 * @return the range of matching activities 197 * @throws PortalException if a permission checker was not initialized 198 */ 199 public static com.liferay.portlet.social.model.SocialActivitySoap[] getActivities( 200 java.lang.String className, int start, int end) 201 throws RemoteException { 202 try { 203 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 204 SocialActivityServiceUtil.getActivities(className, start, end); 205 206 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 207 } 208 catch (Exception e) { 209 _log.error(e, e); 210 211 throw new RemoteException(e.getMessage()); 212 } 213 } 214 215 /** 216 * Returns the number of activities done on assets identified by the class 217 * name ID. 218 * 219 * @param classNameId the target asset's class name ID 220 * @return the number of matching activities 221 */ 222 public static int getActivitiesCount(long classNameId) 223 throws RemoteException { 224 try { 225 int returnValue = SocialActivityServiceUtil.getActivitiesCount(classNameId); 226 227 return returnValue; 228 } 229 catch (Exception e) { 230 _log.error(e, e); 231 232 throw new RemoteException(e.getMessage()); 233 } 234 } 235 236 /** 237 * Returns the number of activities done on the asset identified by the 238 * class name ID and class primary key that are mirrors of the activity 239 * identified by the mirror activity ID. 240 * 241 * @param mirrorActivityId the primary key of the mirror activity 242 * @param classNameId the target asset's class name ID 243 * @param classPK the primary key of the target asset 244 * @return the number of matching activities 245 */ 246 public static int getActivitiesCount(long mirrorActivityId, 247 long classNameId, long classPK) throws RemoteException { 248 try { 249 int returnValue = SocialActivityServiceUtil.getActivitiesCount(mirrorActivityId, 250 classNameId, classPK); 251 252 return returnValue; 253 } 254 catch (Exception e) { 255 _log.error(e, e); 256 257 throw new RemoteException(e.getMessage()); 258 } 259 } 260 261 /** 262 * Returns the number of activities done on the asset identified by the 263 * class name and class primary key that are mirrors of the activity 264 * identified by the mirror activity ID. 265 * 266 * @param mirrorActivityId the primary key of the mirror activity 267 * @param className the target asset's class name 268 * @param classPK the primary key of the target asset 269 * @return the number of matching activities 270 */ 271 public static int getActivitiesCount(long mirrorActivityId, 272 java.lang.String className, long classPK) throws RemoteException { 273 try { 274 int returnValue = SocialActivityServiceUtil.getActivitiesCount(mirrorActivityId, 275 className, classPK); 276 277 return returnValue; 278 } 279 catch (Exception e) { 280 _log.error(e, e); 281 282 throw new RemoteException(e.getMessage()); 283 } 284 } 285 286 /** 287 * Returns the number of activities done on assets identified by class name. 288 * 289 * @param className the target asset's class name 290 * @return the number of matching activities 291 */ 292 public static int getActivitiesCount(java.lang.String className) 293 throws RemoteException { 294 try { 295 int returnValue = SocialActivityServiceUtil.getActivitiesCount(className); 296 297 return returnValue; 298 } 299 catch (Exception e) { 300 _log.error(e, e); 301 302 throw new RemoteException(e.getMessage()); 303 } 304 } 305 306 /** 307 * Returns the activity identified by its primary key. 308 * 309 * @param activityId the primary key of the activity 310 * @return Returns the activity 311 * @throws PortalException if the activity could not be found 312 */ 313 public static com.liferay.portlet.social.model.SocialActivitySoap getActivity( 314 long activityId) throws RemoteException { 315 try { 316 com.liferay.portlet.social.model.SocialActivity returnValue = SocialActivityServiceUtil.getActivity(activityId); 317 318 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModel(returnValue); 319 } 320 catch (Exception e) { 321 _log.error(e, e); 322 323 throw new RemoteException(e.getMessage()); 324 } 325 } 326 327 public static com.liferay.portlet.social.model.SocialActivitySoap[] getActivitySetActivities( 328 long activitySetId, int start, int end) throws RemoteException { 329 try { 330 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 331 SocialActivityServiceUtil.getActivitySetActivities(activitySetId, 332 start, end); 333 334 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 335 } 336 catch (Exception e) { 337 _log.error(e, e); 338 339 throw new RemoteException(e.getMessage()); 340 } 341 } 342 343 /** 344 * Returns a range of all the activities done in the group. 345 * 346 * <p> 347 * This method only finds activities without mirrors. 348 * </p> 349 * 350 * <p> 351 * Useful when paginating results. Returns a maximum of <code>end - 352 * start</code> instances. <code>start</code> and <code>end</code> are not 353 * primary keys, they are indexes in the result set. Thus, <code>0</code> 354 * refers to the first result in the set. Setting both <code>start</code> 355 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 356 * result set. 357 * </p> 358 * 359 * @param groupId the primary key of the group 360 * @param start the lower bound of the range of results 361 * @param end the upper bound of the range of results (not inclusive) 362 * @return the range of matching activities 363 * @throws PortalException if a permission checker was not initialized 364 */ 365 public static com.liferay.portlet.social.model.SocialActivitySoap[] getGroupActivities( 366 long groupId, int start, int end) throws RemoteException { 367 try { 368 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 369 SocialActivityServiceUtil.getGroupActivities(groupId, start, end); 370 371 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 372 } 373 catch (Exception e) { 374 _log.error(e, e); 375 376 throw new RemoteException(e.getMessage()); 377 } 378 } 379 380 /** 381 * Returns the number of activities done in the group. 382 * 383 * <p> 384 * This method only counts activities without mirrors. 385 * </p> 386 * 387 * @param groupId the primary key of the group 388 * @return the number of matching activities 389 */ 390 public static int getGroupActivitiesCount(long groupId) 391 throws RemoteException { 392 try { 393 int returnValue = SocialActivityServiceUtil.getGroupActivitiesCount(groupId); 394 395 return returnValue; 396 } 397 catch (Exception e) { 398 _log.error(e, e); 399 400 throw new RemoteException(e.getMessage()); 401 } 402 } 403 404 /** 405 * Returns a range of activities done by users that are members of the 406 * group. 407 * 408 * <p> 409 * This method only finds activities without mirrors. 410 * </p> 411 * 412 * <p> 413 * Useful when paginating results. Returns a maximum of <code>end - 414 * start</code> instances. <code>start</code> and <code>end</code> are not 415 * primary keys, they are indexes in the result set. Thus, <code>0</code> 416 * refers to the first result in the set. Setting both <code>start</code> 417 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 418 * result set. 419 * </p> 420 * 421 * @param groupId the primary key of the group 422 * @param start the lower bound of the range of results 423 * @param end the upper bound of the range of results (not inclusive) 424 * @return the range of matching activities 425 * @throws PortalException if a permission checker was not initialized 426 */ 427 public static com.liferay.portlet.social.model.SocialActivitySoap[] getGroupUsersActivities( 428 long groupId, int start, int end) throws RemoteException { 429 try { 430 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 431 SocialActivityServiceUtil.getGroupUsersActivities(groupId, 432 start, end); 433 434 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 435 } 436 catch (Exception e) { 437 _log.error(e, e); 438 439 throw new RemoteException(e.getMessage()); 440 } 441 } 442 443 /** 444 * Returns the number of activities done by users that are members of the 445 * group. 446 * 447 * <p> 448 * This method only counts activities without mirrors. 449 * </p> 450 * 451 * @param groupId the primary key of the group 452 * @return the number of matching activities 453 */ 454 public static int getGroupUsersActivitiesCount(long groupId) 455 throws RemoteException { 456 try { 457 int returnValue = SocialActivityServiceUtil.getGroupUsersActivitiesCount(groupId); 458 459 return returnValue; 460 } 461 catch (Exception e) { 462 _log.error(e, e); 463 464 throw new RemoteException(e.getMessage()); 465 } 466 } 467 468 /** 469 * Returns the activity that has the mirror activity. 470 * 471 * @param mirrorActivityId the primary key of the mirror activity 472 * @return Returns the mirror activity 473 * @throws PortalException if the mirror activity could not be found 474 */ 475 public static com.liferay.portlet.social.model.SocialActivitySoap getMirrorActivity( 476 long mirrorActivityId) throws RemoteException { 477 try { 478 com.liferay.portlet.social.model.SocialActivity returnValue = SocialActivityServiceUtil.getMirrorActivity(mirrorActivityId); 479 480 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModel(returnValue); 481 } 482 catch (Exception e) { 483 _log.error(e, e); 484 485 throw new RemoteException(e.getMessage()); 486 } 487 } 488 489 /** 490 * Returns a range of all the activities done in the organization. This 491 * method only finds activities without mirrors. 492 * 493 * <p> 494 * Useful when paginating results. Returns a maximum of <code>end - 495 * start</code> instances. <code>start</code> and <code>end</code> are not 496 * primary keys, they are indexes in the result set. Thus, <code>0</code> 497 * refers to the first result in the set. Setting both <code>start</code> 498 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 499 * result set. 500 * </p> 501 * 502 * @param organizationId the primary key of the organization 503 * @param start the lower bound of the range of results 504 * @param end the upper bound of the range of results (not inclusive) 505 * @return the range of matching activities 506 * @throws PortalException if a permission checker was not initialized 507 */ 508 public static com.liferay.portlet.social.model.SocialActivitySoap[] getOrganizationActivities( 509 long organizationId, int start, int end) throws RemoteException { 510 try { 511 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 512 SocialActivityServiceUtil.getOrganizationActivities(organizationId, 513 start, end); 514 515 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 516 } 517 catch (Exception e) { 518 _log.error(e, e); 519 520 throw new RemoteException(e.getMessage()); 521 } 522 } 523 524 /** 525 * Returns the number of activities done in the organization. This method 526 * only counts activities without mirrors. 527 * 528 * @param organizationId the primary key of the organization 529 * @return the number of matching activities 530 */ 531 public static int getOrganizationActivitiesCount(long organizationId) 532 throws RemoteException { 533 try { 534 int returnValue = SocialActivityServiceUtil.getOrganizationActivitiesCount(organizationId); 535 536 return returnValue; 537 } 538 catch (Exception e) { 539 _log.error(e, e); 540 541 throw new RemoteException(e.getMessage()); 542 } 543 } 544 545 /** 546 * Returns a range of all the activities done by users of the organization. 547 * This method only finds activities without mirrors. 548 * 549 * <p> 550 * Useful when paginating results. Returns a maximum of <code>end - 551 * start</code> instances. <code>start</code> and <code>end</code> are not 552 * primary keys, they are indexes in the result set. Thus, <code>0</code> 553 * refers to the first result in the set. Setting both <code>start</code> 554 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 555 * result set. 556 * </p> 557 * 558 * @param organizationId the primary key of the organization 559 * @param start the lower bound of the range of results 560 * @param end the upper bound of the range of results (not inclusive) 561 * @return the range of matching activities 562 * @throws PortalException if a permission checker was not initialized 563 */ 564 public static com.liferay.portlet.social.model.SocialActivitySoap[] getOrganizationUsersActivities( 565 long organizationId, int start, int end) throws RemoteException { 566 try { 567 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 568 SocialActivityServiceUtil.getOrganizationUsersActivities(organizationId, 569 start, end); 570 571 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 572 } 573 catch (Exception e) { 574 _log.error(e, e); 575 576 throw new RemoteException(e.getMessage()); 577 } 578 } 579 580 /** 581 * Returns the number of activities done by users of the organization. This 582 * method only counts activities without mirrors. 583 * 584 * @param organizationId the primary key of the organization 585 * @return the number of matching activities 586 */ 587 public static int getOrganizationUsersActivitiesCount(long organizationId) 588 throws RemoteException { 589 try { 590 int returnValue = SocialActivityServiceUtil.getOrganizationUsersActivitiesCount(organizationId); 591 592 return returnValue; 593 } 594 catch (Exception e) { 595 _log.error(e, e); 596 597 throw new RemoteException(e.getMessage()); 598 } 599 } 600 601 /** 602 * Returns a range of all the activities done by users in a relationship 603 * with the user identified by the user ID. 604 * 605 * <p> 606 * Useful when paginating results. Returns a maximum of <code>end - 607 * start</code> instances. <code>start</code> and <code>end</code> are not 608 * primary keys, they are indexes in the result set. Thus, <>0</code> refers 609 * to the first result in the set. Setting both <code>start</code> and 610 * <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result 611 * set. 612 * </p> 613 * 614 * @param userId the primary key of the user 615 * @param start the lower bound of the range of results 616 * @param end the upper bound of the range of results (not inclusive) 617 * @return the range of matching activities 618 * @throws PortalException if a permission checker was not initialized 619 */ 620 public static com.liferay.portlet.social.model.SocialActivitySoap[] getRelationActivities( 621 long userId, int start, int end) throws RemoteException { 622 try { 623 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 624 SocialActivityServiceUtil.getRelationActivities(userId, start, 625 end); 626 627 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 628 } 629 catch (Exception e) { 630 _log.error(e, e); 631 632 throw new RemoteException(e.getMessage()); 633 } 634 } 635 636 /** 637 * Returns a range of all the activities done by users in a relationship of 638 * type <code>type</code> with the user identified by <code>userId</code>. 639 * This method only finds activities without mirrors. 640 * 641 * <p> 642 * Useful when paginating results. Returns a maximum of <code>end - 643 * start</code> instances. <code>start</code> and <code>end</code> are not 644 * primary keys, they are indexes in the result set. Thus, <code>0</code> 645 * refers to the first result in the set. Setting both <code>start</code> 646 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 647 * result set. 648 * </p> 649 * 650 * @param userId the primary key of the user 651 * @param type the relationship type 652 * @param start the lower bound of the range of results 653 * @param end the upper bound of the range of results (not inclusive) 654 * @return the range of matching activities 655 * @throws PortalException if a permission checker was not initialized 656 */ 657 public static com.liferay.portlet.social.model.SocialActivitySoap[] getRelationActivities( 658 long userId, int type, int start, int end) throws RemoteException { 659 try { 660 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 661 SocialActivityServiceUtil.getRelationActivities(userId, type, 662 start, end); 663 664 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 665 } 666 catch (Exception e) { 667 _log.error(e, e); 668 669 throw new RemoteException(e.getMessage()); 670 } 671 } 672 673 /** 674 * Returns the number of activities done by users in a relationship with the 675 * user identified by userId. 676 * 677 * @param userId the primary key of the user 678 * @return the number of matching activities 679 */ 680 public static int getRelationActivitiesCount(long userId) 681 throws RemoteException { 682 try { 683 int returnValue = SocialActivityServiceUtil.getRelationActivitiesCount(userId); 684 685 return returnValue; 686 } 687 catch (Exception e) { 688 _log.error(e, e); 689 690 throw new RemoteException(e.getMessage()); 691 } 692 } 693 694 /** 695 * Returns the number of activities done by users in a relationship of type 696 * <code>type</code> with the user identified by <code>userId</code>. This 697 * method only counts activities without mirrors. 698 * 699 * @param userId the primary key of the user 700 * @param type the relationship type 701 * @return the number of matching activities 702 */ 703 public static int getRelationActivitiesCount(long userId, int type) 704 throws RemoteException { 705 try { 706 int returnValue = SocialActivityServiceUtil.getRelationActivitiesCount(userId, 707 type); 708 709 return returnValue; 710 } 711 catch (Exception e) { 712 _log.error(e, e); 713 714 throw new RemoteException(e.getMessage()); 715 } 716 } 717 718 /** 719 * Returns a range of all the activities done by the user. 720 * 721 * <p> 722 * Useful when paginating results. Returns a maximum of <code>end - 723 * start</code> instances. <code>start</code> and <code>end</code> are not 724 * primary keys, they are indexes in the result set. Thus, <code>0</code> 725 * refers to the first result in the set. Setting both <code>start</code> 726 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 727 * result set. 728 * </p> 729 * 730 * @param userId the primary key of the user 731 * @param start the lower bound of the range of results 732 * @param end the upper bound of the range of results (not inclusive) 733 * @return the range of matching activities 734 * @throws PortalException if a permission checker was not initialized 735 */ 736 public static com.liferay.portlet.social.model.SocialActivitySoap[] getUserActivities( 737 long userId, int start, int end) throws RemoteException { 738 try { 739 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 740 SocialActivityServiceUtil.getUserActivities(userId, start, end); 741 742 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 743 } 744 catch (Exception e) { 745 _log.error(e, e); 746 747 throw new RemoteException(e.getMessage()); 748 } 749 } 750 751 /** 752 * Returns the number of activities done by the user. 753 * 754 * @param userId the primary key of the user 755 * @return the number of matching activities 756 */ 757 public static int getUserActivitiesCount(long userId) 758 throws RemoteException { 759 try { 760 int returnValue = SocialActivityServiceUtil.getUserActivitiesCount(userId); 761 762 return returnValue; 763 } 764 catch (Exception e) { 765 _log.error(e, e); 766 767 throw new RemoteException(e.getMessage()); 768 } 769 } 770 771 /** 772 * Returns a range of all the activities done in the user's groups. This 773 * method only finds activities without mirrors. 774 * 775 * <p> 776 * Useful when paginating results. Returns a maximum of <code>end - 777 * start</code> instances. <code>start</code> and <code>end</code> are not 778 * primary keys, they are indexes in the result set. Thus, <code>0</code> 779 * refers to the first result in the set. Setting both <code>start</code> 780 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 781 * result set. 782 * </p> 783 * 784 * @param userId the primary key of the user 785 * @param start the lower bound of the range of results 786 * @param end the upper bound of the range of results (not inclusive) 787 * @return the range of matching activities 788 * @throws PortalException if a permission checker was not initialized 789 */ 790 public static com.liferay.portlet.social.model.SocialActivitySoap[] getUserGroupsActivities( 791 long userId, int start, int end) throws RemoteException { 792 try { 793 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 794 SocialActivityServiceUtil.getUserGroupsActivities(userId, 795 start, end); 796 797 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 798 } 799 catch (Exception e) { 800 _log.error(e, e); 801 802 throw new RemoteException(e.getMessage()); 803 } 804 } 805 806 /** 807 * Returns the number of activities done in user's groups. This method only 808 * counts activities without mirrors. 809 * 810 * @param userId the primary key of the user 811 * @return the number of matching activities 812 */ 813 public static int getUserGroupsActivitiesCount(long userId) 814 throws RemoteException { 815 try { 816 int returnValue = SocialActivityServiceUtil.getUserGroupsActivitiesCount(userId); 817 818 return returnValue; 819 } 820 catch (Exception e) { 821 _log.error(e, e); 822 823 throw new RemoteException(e.getMessage()); 824 } 825 } 826 827 /** 828 * Returns a range of all the activities done in the user's groups and 829 * organizations. This method only finds activities without mirrors. 830 * 831 * <p> 832 * Useful when paginating results. Returns a maximum of <code>end - 833 * start</code> instances. <code>start</code> and <code>end</code> are not 834 * primary keys, they are indexes in the result set. Thus, <code>0</code> 835 * refers to the first result in the set. Setting both <code>start</code> 836 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 837 * result set. 838 * </p> 839 * 840 * @param userId the primary key of the user 841 * @param start the lower bound of the range of results 842 * @param end the upper bound of the range of results (not inclusive) 843 * @return the range of matching activities 844 * @throws PortalException if a permission checker was not initialized 845 */ 846 public static com.liferay.portlet.social.model.SocialActivitySoap[] getUserGroupsAndOrganizationsActivities( 847 long userId, int start, int end) throws RemoteException { 848 try { 849 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 850 SocialActivityServiceUtil.getUserGroupsAndOrganizationsActivities(userId, 851 start, end); 852 853 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 854 } 855 catch (Exception e) { 856 _log.error(e, e); 857 858 throw new RemoteException(e.getMessage()); 859 } 860 } 861 862 /** 863 * Returns the number of activities done in user's groups and organizations. 864 * This method only counts activities without mirrors. 865 * 866 * @param userId the primary key of the user 867 * @return the number of matching activities 868 */ 869 public static int getUserGroupsAndOrganizationsActivitiesCount(long userId) 870 throws RemoteException { 871 try { 872 int returnValue = SocialActivityServiceUtil.getUserGroupsAndOrganizationsActivitiesCount(userId); 873 874 return returnValue; 875 } 876 catch (Exception e) { 877 _log.error(e, e); 878 879 throw new RemoteException(e.getMessage()); 880 } 881 } 882 883 /** 884 * Returns a range of all activities done in the user's organizations. This 885 * method only finds activities without mirrors. 886 * 887 * <p> 888 * Useful when paginating results. Returns a maximum of <code>end - 889 * start</code> instances. <code>start</code> and <code>end</code> are not 890 * primary keys, they are indexes in the result set. Thus, <code>0</code> 891 * refers to the first result in the set. Setting both <code>start</code> 892 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 893 * result set. 894 * </p> 895 * 896 * @param userId the primary key of the user 897 * @param start the lower bound of the range of results 898 * @param end the upper bound of the range of results (not inclusive) 899 * @return the range of matching activities 900 * @throws PortalException if a permission checker was not initialized 901 */ 902 public static com.liferay.portlet.social.model.SocialActivitySoap[] getUserOrganizationsActivities( 903 long userId, int start, int end) throws RemoteException { 904 try { 905 java.util.List<com.liferay.portlet.social.model.SocialActivity> returnValue = 906 SocialActivityServiceUtil.getUserOrganizationsActivities(userId, 907 start, end); 908 909 return com.liferay.portlet.social.model.SocialActivitySoap.toSoapModels(returnValue); 910 } 911 catch (Exception e) { 912 _log.error(e, e); 913 914 throw new RemoteException(e.getMessage()); 915 } 916 } 917 918 /** 919 * Returns the number of activities done in the user's organizations. This 920 * method only counts activities without mirrors. 921 * 922 * @param userId the primary key of the user 923 * @return the number of matching activities 924 */ 925 public static int getUserOrganizationsActivitiesCount(long userId) 926 throws RemoteException { 927 try { 928 int returnValue = SocialActivityServiceUtil.getUserOrganizationsActivitiesCount(userId); 929 930 return returnValue; 931 } 932 catch (Exception e) { 933 _log.error(e, e); 934 935 throw new RemoteException(e.getMessage()); 936 } 937 } 938 939 private static Log _log = LogFactoryUtil.getLog(SocialActivityServiceSoap.class); 940 }