001    /**
002     * Copyright (c) 2000-2012 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.wiki.service.http;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.util.LocaleUtil;
020    
021    import com.liferay.portlet.wiki.service.WikiPageServiceUtil;
022    
023    import java.rmi.RemoteException;
024    
025    /**
026     * <p>
027     * This class provides a SOAP utility for the
028     * {@link com.liferay.portlet.wiki.service.WikiPageServiceUtil} 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     * </p>
033     *
034     * <p>
035     * ServiceBuilder follows certain rules in translating the methods. For example,
036     * if the method in the service utility returns a {@link java.util.List}, that
037     * is translated to an array of {@link com.liferay.portlet.wiki.model.WikiPageSoap}.
038     * If the method in the service utility returns a
039     * {@link com.liferay.portlet.wiki.model.WikiPage}, that is translated to a
040     * {@link com.liferay.portlet.wiki.model.WikiPageSoap}. Methods that SOAP cannot
041     * safely wire are skipped.
042     * </p>
043     *
044     * <p>
045     * The benefits of using the SOAP utility is that it is cross platform
046     * compatible. SOAP allows different languages like Java, .NET, C++, PHP, and
047     * even Perl, to call the generated services. One drawback of SOAP is that it is
048     * slow because it needs to serialize all calls into a text format (XML).
049     * </p>
050     *
051     * <p>
052     * You can see a list of services at http://localhost:8080/api/axis. Set the
053     * property <b>axis.servlet.hosts.allowed</b> in portal.properties to configure
054     * security.
055     * </p>
056     *
057     * <p>
058     * The SOAP utility is only generated for remote services.
059     * </p>
060     *
061     * @author    Brian Wing Shun Chan
062     * @see       WikiPageServiceHttp
063     * @see       com.liferay.portlet.wiki.model.WikiPageSoap
064     * @see       com.liferay.portlet.wiki.service.WikiPageServiceUtil
065     * @generated
066     */
067    public class WikiPageServiceSoap {
068            public static com.liferay.portlet.wiki.model.WikiPageSoap addPage(
069                    long nodeId, java.lang.String title, java.lang.String content,
070                    java.lang.String summary, boolean minorEdit,
071                    com.liferay.portal.service.ServiceContext serviceContext)
072                    throws RemoteException {
073                    try {
074                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.addPage(nodeId,
075                                            title, content, summary, minorEdit, serviceContext);
076    
077                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
078                    }
079                    catch (Exception e) {
080                            _log.error(e, e);
081    
082                            throw new RemoteException(e.getMessage());
083                    }
084            }
085    
086            public static com.liferay.portlet.wiki.model.WikiPageSoap addPage(
087                    long nodeId, java.lang.String title, java.lang.String content,
088                    java.lang.String summary, boolean minorEdit, java.lang.String format,
089                    java.lang.String parentTitle, java.lang.String redirectTitle,
090                    com.liferay.portal.service.ServiceContext serviceContext)
091                    throws RemoteException {
092                    try {
093                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.addPage(nodeId,
094                                            title, content, summary, minorEdit, format, parentTitle,
095                                            redirectTitle, serviceContext);
096    
097                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
098                    }
099                    catch (Exception e) {
100                            _log.error(e, e);
101    
102                            throw new RemoteException(e.getMessage());
103                    }
104            }
105    
106            public static void addPageAttachments(long nodeId, java.lang.String title,
107                    java.util.List<com.liferay.portal.kernel.util.ObjectValuePair<java.lang.String, java.io.InputStream>> inputStreamOVPs)
108                    throws RemoteException {
109                    try {
110                            WikiPageServiceUtil.addPageAttachments(nodeId, title,
111                                    inputStreamOVPs);
112                    }
113                    catch (Exception e) {
114                            _log.error(e, e);
115    
116                            throw new RemoteException(e.getMessage());
117                    }
118            }
119    
120            public static void changeParent(long nodeId, java.lang.String title,
121                    java.lang.String newParentTitle,
122                    com.liferay.portal.service.ServiceContext serviceContext)
123                    throws RemoteException {
124                    try {
125                            WikiPageServiceUtil.changeParent(nodeId, title, newParentTitle,
126                                    serviceContext);
127                    }
128                    catch (Exception e) {
129                            _log.error(e, e);
130    
131                            throw new RemoteException(e.getMessage());
132                    }
133            }
134    
135            public static void deletePage(long nodeId, java.lang.String title)
136                    throws RemoteException {
137                    try {
138                            WikiPageServiceUtil.deletePage(nodeId, title);
139                    }
140                    catch (Exception e) {
141                            _log.error(e, e);
142    
143                            throw new RemoteException(e.getMessage());
144                    }
145            }
146    
147            public static void deletePage(long nodeId, java.lang.String title,
148                    double version) throws RemoteException {
149                    try {
150                            WikiPageServiceUtil.deletePage(nodeId, title, version);
151                    }
152                    catch (Exception e) {
153                            _log.error(e, e);
154    
155                            throw new RemoteException(e.getMessage());
156                    }
157            }
158    
159            public static void deletePageAttachment(long nodeId,
160                    java.lang.String title, java.lang.String fileName)
161                    throws RemoteException {
162                    try {
163                            WikiPageServiceUtil.deletePageAttachment(nodeId, title, fileName);
164                    }
165                    catch (Exception e) {
166                            _log.error(e, e);
167    
168                            throw new RemoteException(e.getMessage());
169                    }
170            }
171    
172            public static void deletePageAttachments(long nodeId, java.lang.String title)
173                    throws RemoteException {
174                    try {
175                            WikiPageServiceUtil.deletePageAttachments(nodeId, title);
176                    }
177                    catch (Exception e) {
178                            _log.error(e, e);
179    
180                            throw new RemoteException(e.getMessage());
181                    }
182            }
183    
184            public static void deleteTempPageAttachment(long nodeId,
185                    java.lang.String fileName, java.lang.String tempFolderName)
186                    throws RemoteException {
187                    try {
188                            WikiPageServiceUtil.deleteTempPageAttachment(nodeId, fileName,
189                                    tempFolderName);
190                    }
191                    catch (Exception e) {
192                            _log.error(e, e);
193    
194                            throw new RemoteException(e.getMessage());
195                    }
196            }
197    
198            public static com.liferay.portlet.wiki.model.WikiPageSoap getDraftPage(
199                    long nodeId, java.lang.String title) throws RemoteException {
200                    try {
201                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.getDraftPage(nodeId,
202                                            title);
203    
204                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
205                    }
206                    catch (Exception e) {
207                            _log.error(e, e);
208    
209                            throw new RemoteException(e.getMessage());
210                    }
211            }
212    
213            public static com.liferay.portlet.wiki.model.WikiPageSoap[] getNodePages(
214                    long nodeId, int max) throws RemoteException {
215                    try {
216                            java.util.List<com.liferay.portlet.wiki.model.WikiPage> returnValue = WikiPageServiceUtil.getNodePages(nodeId,
217                                            max);
218    
219                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModels(returnValue);
220                    }
221                    catch (Exception e) {
222                            _log.error(e, e);
223    
224                            throw new RemoteException(e.getMessage());
225                    }
226            }
227    
228            public static java.lang.String getNodePagesRSS(long nodeId, int max,
229                    java.lang.String type, double version, java.lang.String displayStyle,
230                    java.lang.String feedURL, java.lang.String entryURL)
231                    throws RemoteException {
232                    try {
233                            java.lang.String returnValue = WikiPageServiceUtil.getNodePagesRSS(nodeId,
234                                            max, type, version, displayStyle, feedURL, entryURL);
235    
236                            return returnValue;
237                    }
238                    catch (Exception e) {
239                            _log.error(e, e);
240    
241                            throw new RemoteException(e.getMessage());
242                    }
243            }
244    
245            public static com.liferay.portlet.wiki.model.WikiPageSoap getPage(
246                    long nodeId, java.lang.String title) throws RemoteException {
247                    try {
248                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.getPage(nodeId,
249                                            title);
250    
251                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
252                    }
253                    catch (Exception e) {
254                            _log.error(e, e);
255    
256                            throw new RemoteException(e.getMessage());
257                    }
258            }
259    
260            public static com.liferay.portlet.wiki.model.WikiPageSoap getPage(
261                    long nodeId, java.lang.String title, java.lang.Boolean head)
262                    throws RemoteException {
263                    try {
264                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.getPage(nodeId,
265                                            title, head);
266    
267                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
268                    }
269                    catch (Exception e) {
270                            _log.error(e, e);
271    
272                            throw new RemoteException(e.getMessage());
273                    }
274            }
275    
276            public static com.liferay.portlet.wiki.model.WikiPageSoap getPage(
277                    long nodeId, java.lang.String title, double version)
278                    throws RemoteException {
279                    try {
280                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.getPage(nodeId,
281                                            title, version);
282    
283                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
284                    }
285                    catch (Exception e) {
286                            _log.error(e, e);
287    
288                            throw new RemoteException(e.getMessage());
289                    }
290            }
291    
292            public static java.lang.String getPagesRSS(long companyId, long nodeId,
293                    java.lang.String title, int max, java.lang.String type, double version,
294                    java.lang.String displayStyle, java.lang.String feedURL,
295                    java.lang.String entryURL, String locale) throws RemoteException {
296                    try {
297                            java.lang.String returnValue = WikiPageServiceUtil.getPagesRSS(companyId,
298                                            nodeId, title, max, type, version, displayStyle, feedURL,
299                                            entryURL, LocaleUtil.fromLanguageId(locale));
300    
301                            return returnValue;
302                    }
303                    catch (Exception e) {
304                            _log.error(e, e);
305    
306                            throw new RemoteException(e.getMessage());
307                    }
308            }
309    
310            public static java.lang.String[] getTempPageAttachmentNames(long nodeId,
311                    java.lang.String tempFolderName) throws RemoteException {
312                    try {
313                            java.lang.String[] returnValue = WikiPageServiceUtil.getTempPageAttachmentNames(nodeId,
314                                            tempFolderName);
315    
316                            return returnValue;
317                    }
318                    catch (Exception e) {
319                            _log.error(e, e);
320    
321                            throw new RemoteException(e.getMessage());
322                    }
323            }
324    
325            public static void movePage(long nodeId, java.lang.String title,
326                    java.lang.String newTitle,
327                    com.liferay.portal.service.ServiceContext serviceContext)
328                    throws RemoteException {
329                    try {
330                            WikiPageServiceUtil.movePage(nodeId, title, newTitle, serviceContext);
331                    }
332                    catch (Exception e) {
333                            _log.error(e, e);
334    
335                            throw new RemoteException(e.getMessage());
336                    }
337            }
338    
339            public static void movePageAttachmentFromTrash(long nodeId,
340                    java.lang.String title, java.lang.String deletedFileName)
341                    throws RemoteException {
342                    try {
343                            WikiPageServiceUtil.movePageAttachmentFromTrash(nodeId, title,
344                                    deletedFileName);
345                    }
346                    catch (Exception e) {
347                            _log.error(e, e);
348    
349                            throw new RemoteException(e.getMessage());
350                    }
351            }
352    
353            public static java.lang.String movePageAttachmentToTrash(long nodeId,
354                    java.lang.String title, java.lang.String fileName)
355                    throws RemoteException {
356                    try {
357                            java.lang.String returnValue = WikiPageServiceUtil.movePageAttachmentToTrash(nodeId,
358                                            title, fileName);
359    
360                            return returnValue;
361                    }
362                    catch (Exception e) {
363                            _log.error(e, e);
364    
365                            throw new RemoteException(e.getMessage());
366                    }
367            }
368    
369            public static void movePageToTrash(long nodeId, java.lang.String title)
370                    throws RemoteException {
371                    try {
372                            WikiPageServiceUtil.movePageToTrash(nodeId, title);
373                    }
374                    catch (Exception e) {
375                            _log.error(e, e);
376    
377                            throw new RemoteException(e.getMessage());
378                    }
379            }
380    
381            public static void movePageToTrash(long nodeId, java.lang.String title,
382                    double version) throws RemoteException {
383                    try {
384                            WikiPageServiceUtil.movePageToTrash(nodeId, title, version);
385                    }
386                    catch (Exception e) {
387                            _log.error(e, e);
388    
389                            throw new RemoteException(e.getMessage());
390                    }
391            }
392    
393            public static void restorePageFromTrash(long resourcePrimKey)
394                    throws RemoteException {
395                    try {
396                            WikiPageServiceUtil.restorePageFromTrash(resourcePrimKey);
397                    }
398                    catch (Exception e) {
399                            _log.error(e, e);
400    
401                            throw new RemoteException(e.getMessage());
402                    }
403            }
404    
405            public static com.liferay.portlet.wiki.model.WikiPageSoap revertPage(
406                    long nodeId, java.lang.String title, double version,
407                    com.liferay.portal.service.ServiceContext serviceContext)
408                    throws RemoteException {
409                    try {
410                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.revertPage(nodeId,
411                                            title, version, serviceContext);
412    
413                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
414                    }
415                    catch (Exception e) {
416                            _log.error(e, e);
417    
418                            throw new RemoteException(e.getMessage());
419                    }
420            }
421    
422            public static void subscribePage(long nodeId, java.lang.String title)
423                    throws RemoteException {
424                    try {
425                            WikiPageServiceUtil.subscribePage(nodeId, title);
426                    }
427                    catch (Exception e) {
428                            _log.error(e, e);
429    
430                            throw new RemoteException(e.getMessage());
431                    }
432            }
433    
434            public static void unsubscribePage(long nodeId, java.lang.String title)
435                    throws RemoteException {
436                    try {
437                            WikiPageServiceUtil.unsubscribePage(nodeId, title);
438                    }
439                    catch (Exception e) {
440                            _log.error(e, e);
441    
442                            throw new RemoteException(e.getMessage());
443                    }
444            }
445    
446            public static com.liferay.portlet.wiki.model.WikiPageSoap updatePage(
447                    long nodeId, java.lang.String title, double version,
448                    java.lang.String content, java.lang.String summary, boolean minorEdit,
449                    java.lang.String format, java.lang.String parentTitle,
450                    java.lang.String redirectTitle,
451                    com.liferay.portal.service.ServiceContext serviceContext)
452                    throws RemoteException {
453                    try {
454                            com.liferay.portlet.wiki.model.WikiPage returnValue = WikiPageServiceUtil.updatePage(nodeId,
455                                            title, version, content, summary, minorEdit, format,
456                                            parentTitle, redirectTitle, serviceContext);
457    
458                            return com.liferay.portlet.wiki.model.WikiPageSoap.toSoapModel(returnValue);
459                    }
460                    catch (Exception e) {
461                            _log.error(e, e);
462    
463                            throw new RemoteException(e.getMessage());
464                    }
465            }
466    
467            private static Log _log = LogFactoryUtil.getLog(WikiPageServiceSoap.class);
468    }