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