diff options
Diffstat (limited to 'tderesources/egroupware/xmlrpciface.cpp')
| -rw-r--r-- | tderesources/egroupware/xmlrpciface.cpp | 464 |
1 files changed, 464 insertions, 0 deletions
diff --git a/tderesources/egroupware/xmlrpciface.cpp b/tderesources/egroupware/xmlrpciface.cpp new file mode 100644 index 000000000..d43613e65 --- /dev/null +++ b/tderesources/egroupware/xmlrpciface.cpp @@ -0,0 +1,464 @@ +/************************************************************************** +* Copyright (C) 2003 - 2004 by Frerich Raabe <[email protected]> * +* Tobias Koenig <[email protected]> * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +***************************************************************************/ + +#include <tqfile.h> + +#include <kdebug.h> +#include <kio/job.h> +#include <klocale.h> +#include <kmdcodec.h> + +#include "debugdialog.h" +#include "xmlrpciface.h" + +using namespace KXMLRPC; + +namespace KXMLRPC +{ + class Result + { + friend class Query; + public: + Result() + { } + + bool success() const + { + return m_success; + } + int errorCode() const + { + return m_errorCode; + } + TQString errorString() const + { + return m_errorString; + } + TQValueList<TQVariant> data() const + { + return m_data; + } + + private: + bool m_success; + int m_errorCode; + TQString m_errorString; + TQValueList<TQVariant> m_data; + }; +} + +Query *Query::create( const TQVariant &id, TQObject *parent, const char *name ) +{ + return new Query( id, parent, name ); +} + +void Query::call( const TQString &server, const TQString &method, + const TQValueList<TQVariant> &args, const TQString &userAgent ) +{ + const TQString xmlMarkup = markupCall( method, args ); + DebugDialog::addMessage( xmlMarkup, DebugDialog::Output ); + + TQByteArray postData; + TQDataStream stream( postData, IO_WriteOnly ); + stream.writeRawBytes( xmlMarkup.utf8(), xmlMarkup.utf8().length() ); + + TDEIO::TransferJob *job = TDEIO::http_post( KURL( server ), postData, false ); + if ( !job ) { + kdWarning() << "Unable to create KIO job for " << server << endl; + return; + } + job->addMetaData( "UserAgent", userAgent ); + job->addMetaData( "content-type", "Content-Type: text/xml; charset=utf-8" ); + job->addMetaData( "ConnectTimeout", "50" ); + + connect( job, TQT_SIGNAL( data( TDEIO::Job *, const TQByteArray & ) ), + this, TQT_SLOT( slotData( TDEIO::Job *, const TQByteArray & ) ) ); + connect( job, TQT_SIGNAL( result( TDEIO::Job * ) ), + this, TQT_SLOT( slotResult( TDEIO::Job * ) ) ); + + m_pendingJobs.append( job ); +} + +void Query::slotData( TDEIO::Job *, const TQByteArray &data ) +{ + unsigned int oldSize = m_buffer.size(); + m_buffer.resize( oldSize + data.size() ); + memcpy( m_buffer.data() + oldSize, data.data(), data.size() ); +} + +void Query::slotResult( TDEIO::Job *job ) +{ + m_pendingJobs.remove( job ); + + if ( job->error() != 0 ) + { + emit fault( job->error(), job->errorString(), m_id ); + emit finished( this ); + return ; + } + + TQString data = TQString::fromUtf8( m_buffer.data(), m_buffer.size() ); + DebugDialog::addMessage( data, DebugDialog::Input ); + + TQDomDocument doc; + TQString errMsg; + int errLine, errCol; + if ( !doc.setContent( data, false, &errMsg, &errLine, &errCol ) ) + { + emit fault( -1, i18n( "Received invalid XML markup: %1 at %2:%3" ) + .arg( errMsg ).arg( errLine ).arg( errCol ), m_id ); + emit finished( this ); + return ; + } + + m_buffer.truncate( 0 ); + + if ( isMessageResponse( doc ) ) + emit message( parseMessageResponse( doc ).data(), m_id ); + else if ( isFaultResponse( doc ) ) + { + emit fault( parseFaultResponse( doc ).errorCode(), parseFaultResponse( doc ).errorString(), m_id ); + } + else + { + emit fault( 1, i18n( "Unknown type of XML markup received" ), m_id ); + } + + emit finished( this ); +} + +bool Query::isMessageResponse( const TQDomDocument &doc ) const +{ + return doc.documentElement().firstChild().toElement().tagName().lower() == "params"; +} + +Result Query::parseMessageResponse( const TQDomDocument &doc ) const +{ + Result response; + response.m_success = true; + + TQDomNode paramNode = doc.documentElement().firstChild().firstChild(); + while ( !paramNode.isNull() ) + { + response.m_data << demarshal( paramNode.firstChild().toElement() ); + paramNode = paramNode.nextSibling(); + } + + return response; +} + +bool Query::isFaultResponse( const TQDomDocument &doc ) const +{ + return doc.documentElement().firstChild().toElement().tagName().lower() == "fault"; +} + +Result Query::parseFaultResponse( const TQDomDocument &doc ) const +{ + Result response; + response.m_success = false; + + TQDomNode errorNode = doc.documentElement().firstChild().firstChild(); + const TQVariant errorVariant = demarshal( errorNode.toElement() ); + response.m_errorCode = errorVariant.toMap() [ "faultCode" ].toInt(); + response.m_errorString = errorVariant.toMap() [ "faultString" ].toString(); + + return response; +} + +TQString Query::markupCall( const TQString &cmd, + const TQValueList<TQVariant> &args ) const +{ + TQString markup = "<?xml version=\"1.0\" ?>\r\n<methodCall>\r\n"; + + markup += "<methodName>" + cmd + "</methodName>\r\n"; + + if ( !args.isEmpty() ) + { + markup += "<params>\r\n"; + TQValueList<TQVariant>::ConstIterator it = args.begin(); + TQValueList<TQVariant>::ConstIterator end = args.end(); + for ( ; it != end; ++it ) + markup += "<param>\r\n" + marshal( *it ) + "</param>\r\n"; + markup += "</params>\r\n"; + } + + markup += "</methodCall>\r\n"; + + return markup; +} + +TQString Query::marshal( const TQVariant &arg ) const +{ + switch ( arg.type() ) + { + case TQVariant::String: + case TQVariant::CString: + { + TQString result = arg.toString(); + result = result.replace( "&", "&" ); + result = result.replace( "\"", """ ); + result = result.replace( "<", "<" ); + result = result.replace( ">", ">" ); + return "<value><string>" + result + "</string></value>\r\n"; + } + case TQVariant::Int: + return "<value><int>" + TQString::number( arg.toInt() ) + "</int></value>\r\n"; + case TQVariant::Double: + return "<value><double>" + TQString::number( arg.toDouble() ) + "</double></value>\r\n"; + case TQVariant::Bool: + { + TQString markup = "<value><boolean>"; + markup += arg.toBool() ? "1" : "0"; + markup += "</boolean></value>\r\n"; + return markup; + } + case TQVariant::ByteArray: + return "<value><base64>" + KCodecs::base64Encode( arg.toByteArray() ) + "</base64></value>\r\n"; + case TQVariant::DateTime: + return "<value><datetime.iso8601>" + arg.toDateTime().toString( Qt::ISODate ) + "</datetime.iso8601></value>\r\n"; + case TQVariant::List: + { + TQString markup = "<value><array><data>\r\n"; + const TQValueList<TQVariant> args = arg.toList(); + TQValueList<TQVariant>::ConstIterator it = args.begin(); + TQValueList<TQVariant>::ConstIterator end = args.end(); + for ( ; it != end; ++it ) + markup += marshal( *it ); + markup += "</data></array></value>\r\n"; + return markup; + } + case TQVariant::Map: + { + TQString markup = "<value><struct>\r\n"; + TQMap<TQString, TQVariant> map = arg.toMap(); + TQMap<TQString, TQVariant>::ConstIterator it = map.begin(); + TQMap<TQString, TQVariant>::ConstIterator end = map.end(); + for ( ; it != end; ++it ) + { + markup += "<member>\r\n"; + markup += "<name>" + it.key() + "</name>\r\n"; + markup += marshal( it.data() ); + markup += "</member>\r\n"; + } + markup += "</struct></value>\r\n"; + return markup; + } + default: + kdWarning() << "Failed to marshal unknown variant type: " << arg.type() << endl; + }; + return TQString(); +} + +TQVariant Query::demarshal( const TQDomElement &elem ) const +{ + Q_ASSERT( elem.tagName().lower() == "value" ); + + const TQDomElement typeElement = elem.firstChild().toElement(); + const TQString typeName = typeElement.tagName().lower(); + + if ( typeName == "string" ) + return TQVariant( typeElement.text() ); + else if ( typeName == "i4" || typeName == "int" ) + return TQVariant( typeElement.text().toInt() ); + else if ( typeName == "double" ) + return TQVariant( typeElement.text().toDouble() ); + else if ( typeName == "boolean" ) + { + if ( typeElement.text().lower() == "true" || typeElement.text() == "1" ) + return TQVariant( true ); + else + return TQVariant( false ); + } + else if ( typeName == "base64" ) + return TQVariant( KCodecs::base64Decode( TQCString(typeElement.text().latin1()) ) ); + else if ( typeName == "datetime" || typeName == "datetime.iso8601" ) + return TQVariant( TQDateTime::fromString( typeElement.text(), Qt::ISODate ) ); + else if ( typeName == "array" ) + { + TQValueList<TQVariant> values; + TQDomNode valueNode = typeElement.firstChild().firstChild(); + while ( !valueNode.isNull() ) + { + values << demarshal( valueNode.toElement() ); + valueNode = valueNode.nextSibling(); + } + return TQVariant( values ); + } + else if ( typeName == "struct" ) + { + TQMap<TQString, TQVariant> map; + TQDomNode memberNode = typeElement.firstChild(); + while ( !memberNode.isNull() ) + { + const TQString key = memberNode.toElement().elementsByTagName( "name" ).item( 0 ).toElement().text(); + const TQVariant data = demarshal( memberNode.toElement().elementsByTagName( "value" ).item( 0 ).toElement() ); + map[ key ] = data; + memberNode = memberNode.nextSibling(); + } + return TQVariant( map ); + } + else + kdWarning() << "Cannot demarshal unknown type " << typeName << endl; + + return TQVariant(); +} + +Query::Query( const TQVariant &id, TQObject *parent, const char *name ) + : TQObject( parent, name ), m_id( id ) +{} + +Query::~Query() +{ + TQValueList<TDEIO::Job*>::Iterator it; + for ( it = m_pendingJobs.begin(); it != m_pendingJobs.end(); ++it ) + (*it)->kill(); +} + +Server::Server( const KURL &url, TQObject *parent, const char *name ) + : TQObject( parent, name ) +{ + if ( url.isValid() ) + m_url = url; + + m_userAgent = "KDE XMLRPC resources"; + + DebugDialog::init(); +} + +Server::~Server() +{ + TQValueList<Query*>::Iterator it; + for ( it = mPendingQueries.begin(); it !=mPendingQueries.end(); ++it ) + (*it)->deleteLater(); + + mPendingQueries.clear(); +} + +void Server::queryFinished( Query *query ) +{ + mPendingQueries.remove( query ); + query->deleteLater(); +} + +void Server::setUrl( const KURL &url ) +{ + m_url = url.isValid() ? url : KURL(); +} + +void Server::call( const TQString &method, const TQValueList<TQVariant> &args, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, const TQVariant &id ) +{ + if ( m_url.isEmpty() ) + kdWarning() << "Cannot execute call to " << method << ": empty server URL" << endl; + + Query *query = Query::create( id, this ); + connect( query, TQT_SIGNAL( message( const TQValueList<TQVariant> &, const TQVariant& ) ), msgObj, messageSlot ); + connect( query, TQT_SIGNAL( fault( int, const TQString&, const TQVariant& ) ), faultObj, faultSlot ); + connect( query, TQT_SIGNAL( finished( Query* ) ), this, TQT_SLOT( queryFinished( Query* ) ) ); + mPendingQueries.append( query ); + + query->call( m_url.url(), method, args, m_userAgent ); +} + +void Server::call( const TQString &method, const TQVariant &arg, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << arg ; + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, int arg, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, bool arg, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, double arg , + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, const TQString &arg , + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, const TQCString &arg, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, const TQByteArray &arg , + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, faultObj, faultSlot, msgObj, messageSlot, id ); +} + +void Server::call( const TQString &method, const TQDateTime &arg, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + args << TQVariant( arg ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +void Server::call( const TQString &method, const TQStringList &arg, + TQObject* msgObj, const char* messageSlot, + TQObject* faultObj, const char* faultSlot, + const TQVariant &id ) +{ + TQValueList<TQVariant> args; + TQStringList::ConstIterator it = arg.begin(); + TQStringList::ConstIterator end = arg.end(); + for ( ; it != end; ++it ) + args << TQVariant( *it ); + call( method, args, msgObj, messageSlot, faultObj, faultSlot, id ); +} + +#include "xmlrpciface.moc" |