To retrieve all the blog posts from WordPress you can use the WordPress API, which uses the XML-RPC protocol. I will show you how this could be done in Java.

First, we need the Apache XML-RPC lib. If you use Maven, then you should insert this into your pom file:

<dependency>
   <groupId>org.apache.xmlrpc</groupId>
   <artifactId>xmlrpc-client</artifactId>
   <version>3.1.2</version>
</dependency>

If necessary, change the above version to a newer one. If you dont use Maven, then you should download and insert the lib to your project manually.

Before we start grabbing the blog posts, some initializing has to be done:

final XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
config.setServerURL(new URL("https://homeilja.wordpress.com/xmlrpc.php"));

final XmlRpcClient client = new XmlRpcClient();
client.setConfig(config);

Now the XmlRpcClient knows from which blog we want to retrieve our posts. Note, that you must provide the XML-RPC url of your blog. Typically you just need to set /xmlrpc.php at the end of your blog url.

Now we can interact with our WordPress installation over XML-RPC. If you want to know what methods are supported, you should look into the xmlrpc.php of your WordPress source. Here are all the methods from WordPress 2.8.4:

 // WordPress API
 'wp.getUsersBlogs'        => 'this:wp_getUsersBlogs',
 'wp.getPage'            => 'this:wp_getPage',
 'wp.getPages'            => 'this:wp_getPages',
 'wp.newPage'            => 'this:wp_newPage',
 'wp.deletePage'            => 'this:wp_deletePage',
 'wp.editPage'            => 'this:wp_editPage',
 'wp.getPageList'        => 'this:wp_getPageList',
 'wp.getAuthors'            => 'this:wp_getAuthors',
 'wp.getCategories'        => 'this:mw_getCategories',        // Alias
 'wp.getTags'            => 'this:wp_getTags',
 'wp.newCategory'        => 'this:wp_newCategory',
 'wp.deleteCategory'        => 'this:wp_deleteCategory',
 'wp.suggestCategories'    => 'this:wp_suggestCategories',
 'wp.uploadFile'            => 'this:mw_newMediaObject',    // Alias
 'wp.getCommentCount'    => 'this:wp_getCommentCount',
 'wp.getPostStatusList'    => 'this:wp_getPostStatusList',
 'wp.getPageStatusList'    => 'this:wp_getPageStatusList',
 'wp.getPageTemplates'    => 'this:wp_getPageTemplates',
 'wp.getOptions'            => 'this:wp_getOptions',
 'wp.setOptions'            => 'this:wp_setOptions',
 'wp.getComment'            => 'this:wp_getComment',
 'wp.getComments'        => 'this:wp_getComments',
 'wp.deleteComment'        => 'this:wp_deleteComment',
 'wp.editComment'        => 'this:wp_editComment',
 'wp.newComment'            => 'this:wp_newComment',
 'wp.getCommentStatusList' => 'this:wp_getCommentStatusList',

 // Blogger API
 'blogger.getUsersBlogs' => 'this:blogger_getUsersBlogs',
 'blogger.getUserInfo' => 'this:blogger_getUserInfo',
 'blogger.getPost' => 'this:blogger_getPost',
 'blogger.getRecentPosts' => 'this:blogger_getRecentPosts',
 'blogger.getTemplate' => 'this:blogger_getTemplate',
 'blogger.setTemplate' => 'this:blogger_setTemplate',
 'blogger.newPost' => 'this:blogger_newPost',
 'blogger.editPost' => 'this:blogger_editPost',
 'blogger.deletePost' => 'this:blogger_deletePost',

 // MetaWeblog API (with MT extensions to structs)
 'metaWeblog.newPost' => 'this:mw_newPost',
 'metaWeblog.editPost' => 'this:mw_editPost',
 'metaWeblog.getPost' => 'this:mw_getPost',
 'metaWeblog.getRecentPosts' => 'this:mw_getRecentPosts',
 'metaWeblog.getCategories' => 'this:mw_getCategories',
 'metaWeblog.newMediaObject' => 'this:mw_newMediaObject',

 // MetaWeblog API aliases for Blogger API
 // see http://www.xmlrpc.com/stories/storyReader$2460
 'metaWeblog.deletePost' => 'this:blogger_deletePost',
 'metaWeblog.getTemplate' => 'this:blogger_getTemplate',
 'metaWeblog.setTemplate' => 'this:blogger_setTemplate',
 'metaWeblog.getUsersBlogs' => 'this:blogger_getUsersBlogs',

 // MovableType API
 'mt.getCategoryList' => 'this:mt_getCategoryList',
 'mt.getRecentPostTitles' => 'this:mt_getRecentPostTitles',
 'mt.getPostCategories' => 'this:mt_getPostCategories',
 'mt.setPostCategories' => 'this:mt_setPostCategories',
 'mt.supportedMethods' => 'this:mt_supportedMethods',
 'mt.supportedTextFilters' => 'this:mt_supportedTextFilters',
 'mt.getTrackbackPings' => 'this:mt_getTrackbackPings',
 'mt.publishPost' => 'this:mt_publishPost',

 // PingBack
 'pingback.ping' => 'this:pingback_ping',
 'pingback.extensions.getPingbacks' => 'this:pingback_extensions_getPingbacks',

 'demo.sayHello' => 'this:sayHello',
 'demo.addTwoNumbers' => 'this:addTwoNumbers'

We first have to use the method wp.getUsersBlogs, to get all blogs of the user:

final Object[] params = { new String("myName"), new String("myPassword") };

final Object[] obj = (Object[]) client.execute("wp.getUsersBlogs", params);

for (final Object o : obj) {
   final Map m = (Map) o;
   final boolean isAdmin = (Boolean) m.get("isAdmin");
   final String url = (String) m.get("url");
   final String blogId = (String) m.get("blogid");
   final String blogName = (String) m.get("blogName");
   final String xmlRpcUrl = (String) m.get("xmlrpc");
}

As you can see, we must provide the account name and password of the blog. The interesting part of the retrieved data is the blogId, as this is needed to retrieve the posts from our blog.

Ok, lets start the grabbing:

final Object[] params = { blogId, new String("myName"), new String("myPassword"), 9999 };

final Object[] obj = (Object[]) client.execute("metaWeblog.getRecentPosts", params);

for (final Object o : obj) {
   final Map m = (Map) o;
   final String postid = (String) m.get("postid");
   final String mt_allow_comment = (String) m.get("mt_allow_comment");
   final String permaLink = (String) m.get("permaLink");
   final String post_status = (String) m.get("post_status");
   final String link = (String) m.get("link");
   final String mt_excerpt = (String) m.get("mt_excerpt");
   final String userid = (String) m.get("userid");
   final String mt_text_more = (String) m.get("mt_text_more");
   final int mt_allow_pings = (Integer) m.get("mt_allow_pings");
   final String mt_keywords = (String) m.get("mt_keywords");
   final String title = (String) m.get("title");
   final Date date_created_gmt = (Date) m.get("date_created_gmt");
   final String wp_password = (String) m.get("wp_password");
   final String description = (String) m.get("description");
   final Date dateCreated = (Date) m.get("dateCreated");
   final Object[] categories = (Object[]) m.get("categories");
   for (final Object cat : categories) {
      final String category = (String) cat;
   }
   final String wp_author_id = (String) m.get("wp_author_id");
   final String wp_slug = (String) m.get("wp_slug");
   final String wp_author_display_name = (String) m.get("wp_author_display_name");
}

Thats it. If you wonder what the 9999 means in the code: With this number you can tell WordPress how many of your latest posts you want to grab. So if you want to grab all your posts, then you have to give it a big number. 9999 should be ok in most cases.

new String("myName")

É Hoje implementei um sistema de postagens múltiplas em meu site.

A algum tempo baixei um tal de Windows Live Writer mais até ontem não tinha me preocupado em saber pra que servia.

Lendo notícias em sites como sempre faço, descobri que poderia ser possível postar notícias no Joomla utilizando esta ferramenta da Microsoft. Mais que isso, seria possível postar em múltiplos sites e blogs simultaneamente, economizado muito tempo.

Esse sistema utiliza o XML-RPC que faz a ligação do editor com o Joomla ou outros tipos de blogs.

O plug-in que estou utilizando chama-se XML-RPC – metaWeblog API, infelizmente este plug-in conta com 1 bug na parte de configuração de hora de postagens relacionada à dateTime.iso8601 que faz com que a data de postagem do artigo apareça no Joomla com 3 horas de diferença, ou seja, ainda não descobri como fazer o plug-in entender o fuso-horário gmt-3 que é o horário brasileiro.

O Sistema de múltiplas postagens está funcionando normalmente, o único trabalho adicional que tenho é acessar a administração do site e mudar o horário em 3 horas ^^

Utilizarei o Windows Live Writer para postar minhas notícias. Essas Notícias poderão ser acompanhadas em 3 sites distintos porém com o mesmo conteúdo. São eles:

No meu Site oficial: http://www.wedsigner.com.br

No meu Espaço: http://bolodecenora.spaces.live.com

E no meu Blog: http://disbarara.blogspot.com/

E agora tbm no WordPress ^^ http://wedesigner.wordpress.com

Além das Postagens, Links para as Notícias serão postadas no meu Twitter junto com o Título.

Continuem Acessando este site. Informação Úteis e inúteis diariamente.

Als ich mir heute mal die API für wördpress über XML-RPC angeschaut habe, da habe ich die wohl umständlichste und langsamste metode gefunden, zwei zahlen miteinander zu addieren — man verwende hierfür einfach eine testfunktion in wördpress. Eine implementation in Python 2.6 sieht so aus: (In Python 3 heißt das modul anders.)

import xmlrpclib
URL = 'URL zur xmlrpc.php eines WP-Blogs'

def inefficient_add(a, b):
  xmlrpc = xmlrpclib.ServerProxy(URL)
  return xmlrpc.demo.addTwoNumbers(a, b)

if __name__ = '__main__':
  print inefficient_add(1, 1)

Natürlich muss die URL gegen eine richtige ausgetauscht werden, wenn man mal wieder so richtig auf die einsicht warten will, dass eins und eins eben zwei ergibt.

Übrigens beschäftige ich mich gerade mit so etwas, weil ich mich gerade mal wieder darüber aufrege, dass es keinen einziges brauchbares blog-programm für linux gibt — deshalb muss ich mal wieder selbst ein bisschen häcken. Als ob man nix besseres mit seinem leben zu tun hätte…

Or, developing Django data applications without a database.

In recent months I have been working intensively on a user interface to a data store that lives behind a web services API.  While this might not be considered a natural fit for Django, the smart de-coupling of URLs, views, and templates from data models means that the former retain their value even without the latter.  And hey, it’s all just Python, right?  Django models are just one way to handle data in your application, albeit a very convenient and powerful one when dealing with an RDBMS.

Before working on this project, I had already developed two other Django apps based on data sources accessed via HTTP, both of which were read-only, which of course made things quite a bit simpler.  The first of these was an XML-RPC interface (built with django_xmlrpc, Python’s standard xmlrpclib module and python-ldap) to an LDAP directory.  I manage user and group information for a number of staff applications, including Django itself, for which it is very useful to draw upon a central source of personnel data.  The Django-based service provides convenient methods for common operations while hiding the complexities of LDAP connections and search queries.

The second app dealt with requests to web services of a library catalog which return content in a custom XML format.  Since only HTTP GET requests were required, I used Python’s standard urllib and urllib2 modules for the request/response handling, and lxml.etree for the XML parsing and XSLT application (see also my previous post on the virtues of lxml).

The current project, as opposed to the previous two, involves both read and write actions on the backend data store.  Also, because the web services API implements a REST architecture, the “client” code I was tasked with has to support a wider range of HTTP request methods (not just GET and POST) and responses.  Finally, the client code stack includes a full-blown user interface (the ultimate purpose of the app) for managing the backend data.  In my next post, I’ll talk about how I broke down the problem.

Ett alternativ till att logga in på sin blogg när man ska skriva något, är att skaffa sig en klient där man kan skriva inläggen och sedan ladda upp dem när man är klar. Ska man inte ha med några bilder eller redan har lagt upp dem, så är det här ett smidigt sätt. Jag testar här ett program som heter Drivel.

För att det här ska fungera, måste man på sin blogg ha aktiverat möjligheten att ladda upp med Atom Publishing Protocol eller XML-RPC. I WordPress hittar man den funktionen under Inställningar – Skriva. Markera de två rutorna och det är klart. Det verkar dock som om det på wordpress.com inte fungerar på det sättet. Där är det aktiverat som standard, för alternativet finns inte där. Jag hittar det i alla fall inte.

Du installerar Drivel med hjälp av Pakethanteraren. Paketet du letar efter heter helt enkelt drivel. Efter installationen hittar du det under menyn Program – Internet – Dagboksredigeraren Drivel.

I inloggningsfönstret ska man ange följande uppgifter.

• Namnet på kontot
• Lösenordet
• Vilken slags dagbok det handlar om. WordPress fanns inte med, men det fungerade med Moveable Type.
• Adressen till bloggen. Antagligen http://dinblogg/xmlrpc.php. Det är alltså adressen till filen xmlrpc.php som är intressant. Den ligger antagligen direkt under din bloggadress.

Klicka sedan på Logga in. Du får nu upp fönstret där du ska skriva ditt inlägg. Det enklaste är att bara skriva ett ämne, texten och posta. Men det går också att välja vilken kategori inlägget ska hamna i.

Det går bra klicka på Arbeta frånkopplat. Du får då upp samma ruta att skriva i, men istället för en knappa att post så finns det Spara utkast. Man sparar då utkastet i lämplig mapp. När man öppnar Drivel igen, hittar man sina utkast under Dagbok – Senaste utkast.

Den enda riktiga nackdelen jag upptäckt så här långt, är att man inte kan lägga till etiketter, taggar.

Jag kan nämna att jag har testat Tomboy Blogposter, som finns i Ubuntus Pakethanterare. Där är det ännu enklare att skriva och ladda upp, men det finns en del formateringar, möjligheten att välja kategori och länkar som jag saknar.

Andra program man kan hitta i Pakethanteraren är Gnome Blog och Charm. De har jag ännu inte testat.

Det här verket av Maths Göthe är licensierat under Creative Commons Erkännande-Dela Lika 2.5 Sverige License.

Christian escribió un artículo hace unos días sobre la manera de usar NuSOAP para crear un servicio web. El artículo describe en detalles el procedimiento. No obstante, probar de retornar un arreglo es un trabajo bastante complejo en NuSOAP, o por lo menos esta mal documentado. Una excelente referencia (en Inglés) sobre el tema se puede encontrar en el blog de Lyingonthecovers, pero el artículo faltaba (he puesto un comentario ahí) una noción importante que es que NuSOAP debe tener un ‘return’ => ‘xsd:Array’ en su método register() para retornar el formato correcto.

En este artículo, revisaremos como retornar arreglos.

Retornar arreglos simples

Primero, imaginamos, como en el artículo en Inglés de Lyingonthecovers, que queremos hacer un servicio web que retorna, en el caso de Dokeos, detalles sobre un curso.

La función que se encargar de recojer la información se llamará getCourseDetails(), tomará solo un parámetro  tipo string en entrada (para parametros complejos, ver el ejemplo de Christian) y retornará un arreglo del tipo siguiente:

Array(

['code'] => ‘ABC’,

['title'] => ‘English alphabet’,

['url'] => ‘http://www.example.com/ABC’,

['teacher'] => ‘Yannick Warnier’,

['language'] => ‘english’

)

Hemos definido nuestras necesidades, ahora vamos más adelante y registramos el servicio mismo y sus tipos de datos:

$server = new soap_server();

$server->configureWSDL(‘WSCourse’, ‘urn:WSCourse’);

// definimos el tipo complejo (arreglo asociativo, =’struct’) de detalles de curso

$server->wsdl->addComplexType(
‘courseDetails’,
‘complexType’,
’struct’,
‘all’,
”,
array(
‘name’=>’code’  , ‘type’=>’xsd:string’,
‘name’=>’title’  , ‘type’=>’xsd:string’,
‘name’=>’url’    , ‘type’=>’xsd:string’,
‘name’=>’teacher’, ‘type’=>’xsd:string’,
‘name’=>’language’,'type’=>’xsd:string’,
)
);

Por favor apunten que declaramos un tipo, pero no hay ninguna relación, al nivél de esta declaración, entre el tipo y un método. Este tipo podrá ser reutilizado para otros métodos también.

// Registramos el método y su parámetro de entrada
$server->register(‘getCourseDetails’,           // nombre método
array(‘username’ => ‘xsd:string’),            //  parametros entrantes al servicio
array(‘return’ => ‘tns:courseDetails’),     // valor(es) retornado(s)
‘urn:WSCourse’,                                            // namespace (espacio de nombre)
‘urn:WSCourse#getCourseDetails’,         // acción SOAP
‘rpc’,                                                                 // estílo
‘encoded’,                                                       // tipo de uso
‘This service returns a list of courses’    // documentación
);

En este caso, usamos directamente un ’struct’ como valor de retorno. Usamos el marcador ‘tns:’ (probablemente Type NameSpace o algo así) para decir que es un tipo complejo definido por otro lado, y definimos que tipo exactamente queremos usar.

Esto es lo que debería ocurir y, para este caso (no verificado), tal vez funcionaría. Si no funciona, prueben remplazar tns:courseDetails por xsd:Array, simplemente (vemos más abajo casos probados).

En el caso un poco más complejo en que tenga que devolver un arreglo de estos courseDetails, como hago?

Arreglos de arreglos

Una estructura a dos niveles no se puede definir en solo una definición de ComplexType. En sí, se tiene que definir cada nivel como un ComplexType:

$server->wsdl->addComplexType(
‘courseDetails’,
‘complexType’,
’struct’,
‘all’,
”,
array(
‘name’=>’code’  , ‘type’=>’xsd:string’,
‘name’=>’title’  , ‘type’=>’xsd:string’,
‘name’=>’url’    , ‘type’=>’xsd:string’,
‘name’=>’teacher’, ‘type’=>’xsd:string’,
‘name’=>’language’,'type’=>’xsd:string’,
)
);

Nada cambia para esta primera parte. Ahora definimos el arreglo que va a contener estos structs:

$server->wsdl->addComplexType(
‘courseList’,
‘complexType’,
‘array’,
”,
‘SOAP-ENC:Array’,
array(),
array(
array(‘ref’=>’SOAP:ENC:arrayType’,
‘wsdl:arrayType’=>’tns:courseDetails[]‘)
),
‘tns:courseDetails’
);

Bueno, hay mucho que todavía no hemos detallado ahí, pero no es directamente el objetivo de este artículo. Una cosa es importante: esto es la forma de declarar un arreglo (no asociativo, es decir con indices numéricos unicamente) del ComplexType courseDetails.

Una vez que tenemos esto listo, la lógica nos haría pensar que simplemente debería registrar este tipo complejo en mi servicio web:

// Registramos el método y su parámetro de entrada
$server->register(‘getCourseDetails’,           // nombre método
array(‘username’ => ‘xsd:string’),            //  parametros entrantes al servicio
array(‘return’ => ‘tns:courseList’),          // valor(es) retornado(s)
‘urn:WSCourse’,                                            // namespace (espacio de nombre)
‘urn:WSCourse#getCourseDetails’,         // acción SOAP
‘rpc’,                                                                 // estílo
‘encoded’,                                                       // tipo de uso
‘This service returns a list of courses’    // documentación
);

… y ahí es donde perdimos horas buscando. En realidad, parece que hay algo malo ahí, en la forma en que NuSOAP (a lo menos versión de Agosto de 2008) retorna este valor, que es incorrecto. Resulta que el cliente SOAP de PHP5 no entiende el valor retornado. Ni para este arreglo de structs, ni para el struct mismo.

Abandonar la definición de tipos complejos

La solución es de abandonar la idea de definir el tipo de valor retornado, y simplemente usar xsd:Array como valor de retorno:

// Registramos el método y su parámetro de entrada
$server->register(‘getCourseDetails’,           // nombre método
array(‘username’ => ‘xsd:string’),            //  parametros entrantes al servicio
array(‘return’ => ‘xsd:Array’),          // valor(es) retornado(s)
‘urn:WSCourse’,                                            // namespace (espacio de nombre)
‘urn:WSCourse#getCourseDetails’,         // acción SOAP
‘rpc’,                                                                 // estílo
‘encoded’,                                                       // tipo de uso
‘This service returns a list of courses’    // documentación
);

No hay lógica ahí, es cierto, pero a lo menos espero que les ayudarán. Me estoy comunicando con los desarrolladores de NuSOAP para averiguar el tema.

I just checked out http://mashery.com and was thoroughly impressed with their API management tools. From my perspective, being able to offload limiting, reporting and access management into the cloud is amazing. I haven’t gotten through all the details yet and one big question still remains… As the demand on my mashery service increases (or decreases), how will I dynamically adjust the resources at the edge of my app?

Uno de los motivos para mudarme a este sitio era disponer de una interfaz XML-RPC: no me gusta editar con el navegador (se cuelga, se corta la sesión, …). En mi búsqueda encontré muchos programitas para publicar que utilizan ventanas.

Eso está bien, pero tampoco me gusta mucho: quiero editar un fichero de texto con Vim porque no necesito más, y luego poderlo enviar con una interfaz también textual. Buscando por ahí encontré dos soluciones: vimpress y vimblog.

En principio era más favorable al primero, porque usa Python y estoy más acostumbrado a ese lenguaje pero rápidamente descubrí que tenía muy pocas primitivas y que el trabajo iba a ser mayor así que me decanté por vimblog (algunos pantallazos).

Aún así, el mundo es imperfecto: su autor no había incluido la posibilidad de añadir etiquetas a una entrada, que es algo que a mi me parece importante, así que me puse manos a la obra para añadirlo: en plan chapuzas, buscando líneas de código que se parecen a lo que yo quería hacer (esencialmente, modificando el código correspondiente a las categorías) y copiando y pegando, pero parece que funciona.

Como persona educada, le envié al autor, Pedro mg, un mensaje y el código, por si le apetecía echarle un vistazo y me invitó a hacer un ‘fork’ de su proyecto y publicarlo por mi cuenta, cosa que he hecho en vimblog.vim (bis) que de paso me ha hecho darle una segunda oportunidad a git con github.

Ibarat sebuah benda, tidak akan pernah dilihat jika tidak ada cahaya yang memantul dari benda ke mata kita. Logis bukan? Hal yang sama diterapkan pada blog. Jika tidak ada “cahaya” dalam suatu blog, maka blog itu, sebagus apapun isinya, seindah apapun bahasanya, selucu apapun guyonannya, tetap saja tidak akan “terlihat”. Hal yang dianut oleh pelajaran SEO.

WordPress, adalah sebuah CMS multiplatform dan multiguna yang sudah terintregrasi SEO yang handal. Salah satunya platform XML RPC. Platform sederhana yang berfungsi memancarkan “cahaya” blog ke dalam mesin pencari.

Tidak…
Anda salah jika mengira saya akan menjelaskan cara kerjanya. Berikut ini list dari berbagai pinger service yang ada. Cukup banyak. Jika anda pengguna skrip wordpress (bukan wordpress.com). Silahkan di ADMIN PANEL >> SETTING >> WRITING.

Masukkan kode XML RPC berikut ke colomnya.
http://1470.net/api/ping

http://zing.zingfast.com

Daaaan.. selamat datang cahaya!

import xmlrpclib

user = 'username'
passwd = 'password'
server = xmlrpclib.ServerProxy('http://vizible.wordpress.com/xmlrpc.php')

blog_id = 0
title = 'test title' 
content = 'test content, from python'

blog_content = { 'title' : title, 'description' : content }
categories = [{'categoryId' : 'programming', 'isPrimary' : 1}] 

post_id = int(server.metaWeblog.newPost(blog_id, user, passwd, blog_content,0))
server.mt.setPostCategories(post_id, user, passwd, categories) # not work
server.mt.publishPost(post_id, user, passwd)
|

Reference — http://www.blackbirdblog.it/programmazione/progetti/28

|

Now days most web services are implemented with the REST style architecture rather than a SOAP one. Lets step explain what REST is.
What is a REST Web Service

The acronym REST stands for Representational State Transfer,
this basically means that each unique URL is a representation of some
object. You can get the contents of that object using an HTTP GET, to
delete it, you then might use a POST, PUT, or DELETE to modify the
object (in practice most of the services use a POST for this).
Who’s using REST?

All of Yahoo’s web services use REST, including Flickr, del.icio.us
API uses it, pubsub, bloglines, technorati, and both eBay, and Amazon
have web services for both REST and SOAP.
Who’s using SOAP?
Google seams to be consistent in implementing their web services to
use SOAP, with the exception of Blogger, which uses XML-RPC. You will
find SOAP web services in lots of enterprise software as well.
REST vs SOAP

As you may have noticed the companies I mentioned that are using
REST api’s haven’t been around for very long, and their apis came out
this year mostly. So REST is definitely the trendy way to create a web
service.
The main advantages of REST web services are:

Lightweight – not a lot of extra xml markup
Human Readable Results
Easy to build – no toolkits required

SOAP also has some advantages:

Easy to consume – sometimes
Rigid – type checking,
Adheres to a contract
Development tools

For consuming web services, its sometimes a toss up between which is
easier. For instance Google’s AdWords web service is really hard to
consume, it uses SOAP headers, and a number of other
things that make it kind of difficult. On the converse, Amazon’s REST
web service can sometimes be tricky to parse because it can be highly
nested, and the result schema can vary quite a bit based on what you
search for.

XmlRpcRequest [-Url] <[String]> [-MethodName] <[String]> [-Params] <[Object]>
Return Xml-Rpc methodResponse

XmlRpcMethodCall [-Name] <[String]> [-Params] <[Object]>
Return Xml-Rpc methodCall

XmlRpcType [-Value] <[Object]>
Return Xml-Rpc value

function XmlRpcType()
{
param( [Object]$Value )

if($Value -ne $NULL){ [string]$Type=$Value.GetType().Name }
else{ $Type=$FALSE }

if((‘Int32′,’Double’,'Boolean’,'String’,'Base64′,’False’) -contains $Type)
{
if($Type){ [string]“<$($Type)><value>$($Value)</value></$($Type)>” }
else{ [string]“<value></value>” }
}
if(‘DateTime’ -eq $Type)
{
[string]“<value><dateTime.iso8601>$($Value.ToString(‘yyyyMMddTHH:mm:ss’))</dateTime.iso8601></value>”
}
if($Value -is [Array])
{
[string]“<value><array><data>$(&{ $Value | %{ “$(&{ XmlRpcType $_ })”}})</data></array></value>”
}
if(‘Hashtable’ -eq $Type)
{
[string]“<value><struct>$(&{ $Value.Keys | %{ “<member><name>$($_)</name>$(&{ XmlRpcType $Value[$_] })</member>” } })</struct></value>”
}
}

function XmlRpcMethodCall()
{
param
(
[String]$Name=$(throw “Method name is requried parameter!”),
[Object]$Params
)

[String]((&{
“<?xml version=’1.0′?><methodCall><methodName>$($Name)</methodName><params>”
if($Params){$Params | %{ “<param>$(&{XmlRpcType $_})</param>” } }
else{“<param>$(&{XmlRpcType $NULL})</param>”}
“</params></methodCall>”
}) -join(”))

}

function XmlRpcRequest()
{
param(
[String]$Url,
[String]$MethodName,
[Object]$Params
)

if($Url -and $MethodName){
try{
($doc=New-Object Xml.XmlDocument).LoadXml(
(New-Object Net.WebClient).UploadString(
$Url,
(XmlRpcMethodCall $MethodName $Params)
)
)
[Xml.XmlDocument]$doc
}
catch [System.Net.WebException],[System.IO.IOException] {‘WebClient Error’}
catch {‘Unhandle Error’}
finally {}
}
}