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