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