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