001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/enterprise/control/RPCFactory.java $
002    /*----------------------------------------------------------------------------
003     This file is part of deegree, http://deegree.org/
004     Copyright (C) 2001-2009 by:
005       Department of Geography, University of Bonn
006     and
007       lat/lon GmbH
008    
009     This library is free software; you can redistribute it and/or modify it under
010     the terms of the GNU Lesser General Public License as published by the Free
011     Software Foundation; either version 2.1 of the License, or (at your option)
012     any later version.
013     This library is distributed in the hope that it will be useful, but WITHOUT
014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016     details.
017     You should have received a copy of the GNU Lesser General Public License
018     along with this library; if not, write to the Free Software Foundation, Inc.,
019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020    
021     Contact information:
022    
023     lat/lon GmbH
024     Aennchenstr. 19, 53177 Bonn
025     Germany
026     http://lat-lon.de/
027    
028     Department of Geography, University of Bonn
029     Prof. Dr. Klaus Greve
030     Postfach 1147, 53001 Bonn
031     Germany
032     http://www.geographie.uni-bonn.de/deegree/
033    
034     e-mail: info@deegree.org
035    ----------------------------------------------------------------------------*/
036    package org.deegree.enterprise.control;
037    
038    import java.io.Reader;
039    import java.util.Date;
040    
041    import org.deegree.framework.log.ILogger;
042    import org.deegree.framework.log.LoggerFactory;
043    import org.deegree.framework.util.TimeTools;
044    import org.deegree.framework.xml.ElementList;
045    import org.deegree.framework.xml.NamespaceContext;
046    import org.deegree.framework.xml.XMLTools;
047    import org.deegree.ogcbase.CommonNamespaces;
048    import org.w3c.dom.Document;
049    import org.w3c.dom.Element;
050    
051    /**
052     * Factory for creating RPC methodCall and methodResponse objects from their XML representation.
053     *
054     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
055     * @author last edited by: $Author: mschneider $
056     *
057     * @version $Revision: 18195 $ $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
058     */
059    public class RPCFactory {
060    
061        private static final ILogger LOG = LoggerFactory.getLogger( RPCFactory.class );
062    
063        private static NamespaceContext nsContext = CommonNamespaces.getNamespaceContext();
064    
065        /**
066         * Creates an instance of <code>RPCMethodCall</code> from an XML document that can be accessed through the passed
067         * <code>Reader</code>.
068         *
069         * @param reader
070         *            reader to access an XML document
071         * @return an RPCMethodCall
072         * @throws RPCException
073         */
074        public static RPCMethodCall createRPCMethodCall( Reader reader )
075                                throws RPCException {
076    
077            Document doc = null;
078            try {
079                doc = XMLTools.parse( reader );
080            } catch ( Exception e ) {
081                LOG.logError( e.getMessage(), e );
082                throw new RPCException( e.toString() );
083            }
084    
085            return createRPCMethodCall( doc );
086        }
087    
088        /**
089         * Creates an instance of <code>RPCMethodCall</code> from the given XML document.
090         *
091         * @param doc
092         *            XML document containing a RPC method call
093         * @return an RPCMethodCall
094         * @throws RPCException
095         */
096        public static RPCMethodCall createRPCMethodCall( Document doc )
097                                throws RPCException {
098    
099            RPCMethodCall mc = null;
100            try {
101                Element root = doc.getDocumentElement();
102                // get methode name - mandatory
103                String methodName = XMLTools.getRequiredStringValue( "methodName", null, root );
104    
105                Element params = XMLTools.getChildElement( "params", null, root );
106    
107                RPCParameter[] parameters = null;
108                if ( params != null ) {
109                    ElementList el = XMLTools.getChildElements( params );
110                    if ( el != null ) {
111                        parameters = new RPCParameter[el.getLength()];
112                        for ( int i = 0; i < el.getLength(); i++ ) {
113                            parameters[i] = createRPCParam( el.item( i ) );
114                        }
115                    }
116                } else {
117                    parameters = new RPCParameter[0];
118                }
119    
120                mc = new RPCMethodCall( methodName, parameters );
121            } catch ( Exception e ) {
122                LOG.logError( e.getMessage(), e );
123                throw new RPCException( e.toString() );
124            }
125    
126            return mc;
127        }
128    
129        /**
130         * Creates an instance of <code>RPCMethodResponse</code> from an XML document that can be accessed through the
131         * passed <code>Reader</code>.
132         *
133         * @param reader
134         *            reader to access an XML document
135         * @return created <code>RPCMethodResponse</code>
136         * @throws RPCException
137         */
138        public static RPCMethodResponse createRPCMethodResponse( Reader reader )
139                                throws RPCException {
140    
141            Document doc = null;
142            try {
143                doc = XMLTools.parse( reader );
144            } catch ( Exception e ) {
145                LOG.logError( e.getMessage(), e );
146                throw new RPCException( e.toString() );
147            }
148    
149            return createRPCMethodResponse( doc );
150        }
151    
152        /**
153         * Creates an instance of {@link RPCMethodResponse} from the given XML document.
154         *
155         * @param doc
156         *            XML document containing a RPC method call
157         * @return created <code>RPCMethodResponse</code>
158         * @throws RPCException
159         */
160        public static RPCMethodResponse createRPCMethodResponse( Document doc )
161                                throws RPCException {
162    
163            RPCMethodResponse mc = null;
164            try {
165                Element root = doc.getDocumentElement();
166    
167                Element params = XMLTools.getChildElement( "params", null, root );
168    
169                if ( params != null ) {
170                    ElementList el = XMLTools.getChildElements( params );
171                    RPCParameter[] parameters = null;
172                    if ( el != null ) {
173                        parameters = new RPCParameter[el.getLength()];
174                        for ( int i = 0; i < el.getLength(); i++ ) {
175                            parameters[i] = createRPCParam( el.item( i ) );
176                        }
177                    }
178                    mc = new RPCMethodResponse( parameters );
179                } else {
180                    // a fault is contained instead of the expected result
181                    Element fault = XMLTools.getChildElement( "fault", null, root );
182                    RPCFault rpcFault = createRPCFault( fault );
183                    mc = new RPCMethodResponse( rpcFault );
184                }
185    
186            } catch ( Exception e ) {
187                LOG.logError( e.getMessage(), e );
188                throw new RPCException( e.toString() );
189            }
190    
191            return mc;
192        }
193    
194        /**
195         * Creates an {@link RPCMethodResponse} from the given parameters.
196         *
197         * @param par
198         * @return corresponding <code>RPCMethodResponse</code> object
199         */
200        public static RPCMethodResponse createRPCMethodResponse( RPCParameter[] par ) {
201            RPCMethodResponse mc = null;
202            if ( par != null ) {
203                RPCParameter[] params = par;
204                mc = new RPCMethodResponse( params );
205            } else {
206                LOG.logError( "Error in RPCFactory.createRPCMethodResponse(): par = null." );
207            }
208            return mc;
209        }
210    
211        /**
212         * Creates an <code>RPCParameter</code> from its XML representation.
213         *
214         * @param param
215         *            element containing an RPC parameter
216         * @return created <code>RPCParameter</code>
217         */
218        private static RPCParameter createRPCParam( Element param )
219                                throws RPCException {
220    
221            RPCParameter parameter = null;
222            try {
223                Element value = XMLTools.getChildElement( "value", null, param );
224                Element child = XMLTools.getFirstChildElement( value );
225                Object o = null;
226                Class cl = null;
227                if ( child.getNodeName().equals( "struct" ) ) {
228                    o = createRPCStruct( child );
229                    cl = RPCStruct.class;
230                } else if ( child.getNodeName().equals( "string" ) ) {
231                    o = XMLTools.getRequiredStringValue( "string", null, value );
232                    cl = String.class;
233                } else if ( child.getNodeName().equals( "int" ) ) {
234                    double d = XMLTools.getRequiredNodeAsDouble( value, "./int", nsContext );
235                    o = new Integer( (int) d );
236                    cl = Integer.class;
237                } else if ( child.getNodeName().equals( "i4" ) ) {
238                    double d = XMLTools.getRequiredNodeAsDouble( value, "./i4", nsContext );
239                    o = new Integer( (int) d );
240                    cl = Integer.class;
241                } else if ( child.getNodeName().equals( "double" ) ) {
242                    double d = XMLTools.getRequiredNodeAsDouble( value, "./double", nsContext );
243                    o = new Double( d );
244                    cl = Double.class;
245                } else if ( child.getNodeName().equals( "boolean" ) ) {
246                    o = Boolean.valueOf( child.getFirstChild().getNodeValue().equals( "1" ) );
247                    cl = Boolean.class;
248                } else if ( child.getNodeName().equals( "dateTime.iso8601" ) ) {
249                    String s = XMLTools.getRequiredStringValue( "dateTime.iso8601", null, value );
250                    o = TimeTools.createCalendar( s ).getTime();
251                    cl = Date.class;
252                } else if ( child.getNodeName().equals( "base64" ) ) {
253                } else if ( child.getNodeName().equals( "array" ) ) {
254                    o = createArray( child );
255                    cl = RPCParameter[].class;
256                }
257                parameter = new RPCParameter( cl, o );
258            } catch ( Exception e ) {
259                LOG.logError( e.getMessage(), e );
260                throw new RPCException( e.toString() );
261            }
262    
263            return parameter;
264        }
265    
266        /**
267         * Creates an RPC structure object from the passed <code>Element</code>.
268         *
269         * @param struct
270         *            element containing an RPC struct
271         * @return created <code>RPCStruct</code>
272         */
273        private static RPCStruct createRPCStruct( Element struct )
274                                throws RPCException {
275    
276            RPCStruct structure = null;
277            try {
278                ElementList el = XMLTools.getChildElements( struct );
279                RPCMember[] members = null;
280                if ( el != null ) {
281                    members = new RPCMember[el.getLength()];
282                    for ( int i = 0; i < el.getLength(); i++ ) {
283                        members[i] = createRPCMember( el.item( i ) );
284                    }
285                }
286                structure = new RPCStruct( members );
287            } catch ( Exception e ) {
288                LOG.logError( e.getMessage(), e );
289                throw new RPCException( e.toString() );
290            }
291    
292            return structure;
293        }
294    
295        /**
296         * Creates an RPC structure member object from the passed <code>Element</code>.
297         *
298         * @param member
299         *            element containing an RPC member
300         * @return created <code>RPCMember</code>
301         */
302        private static RPCMember createRPCMember( Element member )
303                                throws RPCException {
304    
305            RPCMember mem = null;
306            try {
307                String name = XMLTools.getRequiredStringValue( "name", null, member );
308                Element value = XMLTools.getChildElement( "value", null, member );
309                Element child = XMLTools.getFirstChildElement( value );
310                Object o = null;
311                Class<?> cl = null;
312                if ( child.getNodeName().equals( "struct" ) ) {
313                    o = createRPCStruct( child );
314                    cl = RPCStruct.class;
315                } else if ( child.getNodeName().equals( "string" ) ) {
316                    o = XMLTools.getRequiredStringValue( "string", null, value );
317                    cl = String.class;
318                } else if ( child.getNodeName().equals( "int" ) ) {
319                    double d = XMLTools.getRequiredNodeAsDouble( value, "./int", nsContext );
320                    o = new Integer( (int) d );
321                    cl = Integer.class;
322                } else if ( child.getNodeName().equals( "i4" ) ) {
323                    double d = XMLTools.getRequiredNodeAsDouble( value, "./i4", nsContext );
324                    o = new Integer( (int) d );
325                    cl = Integer.class;
326                } else if ( child.getNodeName().equals( "double" ) ) {
327                    double d = XMLTools.getRequiredNodeAsDouble( value, "./double", nsContext );
328                    o = new Double( d );
329                    cl = Double.class;
330                } else if ( child.getNodeName().equals( "boolean" ) ) {
331                    o = Boolean.valueOf( child.getFirstChild().getNodeValue().equals( "1" ) );
332                    cl = Boolean.class;
333                } else if ( child.getNodeName().equals( "dateTime.iso8601" ) ) {
334                    String s = XMLTools.getRequiredStringValue( "dateTime.iso8601", null, value );
335                    o = TimeTools.createCalendar( s ).getTime();
336                    cl = Date.class;
337                } else if ( child.getNodeName().equals( "base64" ) ) {
338                    // TODO
339                } else if ( child.getNodeName().equals( "array" ) ) {
340                    o = createArray( child );
341                    cl = RPCParameter[].class;
342                }
343                mem = new RPCMember( cl, o, name );
344            } catch ( Exception e ) {
345                LOG.logError( e.getMessage(), e );
346                throw new RPCException( e.toString() );
347            }
348    
349            return mem;
350        }
351    
352        /**
353         * Creates an array of {@link RPCParameter} objects from the passed <code>Element</code>.
354         *
355         * @param array
356         * @return created array of <code>RPCParameter</code> objects
357         */
358        private static RPCParameter[] createArray( Element array )
359                                throws RPCException {
360    
361            RPCParameter[] param = null;
362            try {
363                Element data = XMLTools.getChildElement( "data", null, array );
364                ElementList el = XMLTools.getChildElements( data );
365                if ( el != null ) {
366                    param = new RPCParameter[el.getLength()];
367                    for ( int i = 0; i < el.getLength(); i++ ) {
368                        Element child = XMLTools.getFirstChildElement( el.item( i ) );
369                        Object o = null;
370                        Class cl = null;
371                        if ( child.getNodeName().equals( "struct" ) ) {
372                            o = createRPCStruct( child );
373                            cl = RPCStruct.class;
374                        } else if ( child.getNodeName().equals( "string" ) ) {
375                            o = XMLTools.getRequiredStringValue( "string", null, el.item( i ) );
376                            cl = String.class;
377                        } else if ( child.getNodeName().equals( "int" ) ) {
378                            double d = XMLTools.getRequiredNodeAsDouble( el.item( i ), "./int", nsContext );
379                            o = new Integer( (int) d );
380                            cl = Integer.class;
381                        } else if ( child.getNodeName().equals( "i4" ) ) {
382                            double d = XMLTools.getRequiredNodeAsDouble( el.item( i ), "./i4", nsContext );
383                            o = new Integer( (int) d );
384                            cl = Integer.class;
385                        } else if ( child.getNodeName().equals( "double" ) ) {
386                            double d = XMLTools.getRequiredNodeAsDouble( el.item( i ), "./double", nsContext );
387                            o = new Double( d );
388                            cl = Double.class;
389                        } else if ( child.getNodeName().equals( "boolean" ) ) {
390                            o = Boolean.valueOf( child.getFirstChild().getNodeValue().equals( "1" ) );
391                            cl = Boolean.class;
392                        } else if ( child.getNodeName().equals( "dateTime.iso8601" ) ) {
393                            String s = XMLTools.getRequiredStringValue( "dateTime.iso8601", null, el.item( i ) );
394                            o = TimeTools.createCalendar( s ).getTime();
395                            cl = Date.class;
396                        } else if ( child.getNodeName().equals( "base64" ) ) {
397                        } else if ( child.getNodeName().equals( "array" ) ) {
398                            o = createArray( child );
399                            cl = RPCParameter[].class;
400                        }
401                        param[i] = new RPCParameter( cl, o );
402                    }
403                }
404            } catch ( Exception e ) {
405                LOG.logError( e.getMessage(), e );
406                throw new RPCException( e.toString() );
407            }
408    
409            return param;
410        }
411    
412        /**
413         * Creates an {@link RPCFault} object from the passed <code>Element</code>.
414         *
415         * @param fault
416         *            fault element
417         * @return created <code>RPCFault</code> object
418         */
419        private static RPCFault createRPCFault( Element fault )
420                                throws RPCException {
421    
422            RPCFault rpcFault = null;
423            try {
424                Element value = XMLTools.getChildElement( "value", null, fault );
425                Element child = XMLTools.getFirstChildElement( value );
426                RPCStruct struct = createRPCStruct( child );
427                String s1 = null;
428                String s2 = null;
429                Object o = struct.getMember( "faultCode" ).getValue();
430                if ( o != null ) {
431                    s1 = o.toString();
432                }
433                o = struct.getMember( "faultString" ).getValue();
434                if ( o != null ) {
435                    s2 = o.toString();
436                }
437                rpcFault = new RPCFault( s1, s2 );
438            } catch ( Exception e ) {
439                LOG.logError( e.getMessage(), e );
440                throw new RPCException( e.toString() );
441            }
442            return rpcFault;
443        }
444    }