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    }