Práctica 7: Bases de datos XML

#!/usr/bin/ruby
require 'rexml/document'
#Debemos añadir la libreria de ruby para Exist
require './existapi.rb'
include REXML

#Parámetros que introduce el usuario
param1 = ARGV[0]
param2 = ARGV[1]

#Vector para almacenar todos los equipos disponibles en la BD
ficheros =Array.new
#Vectores y variables auxiliares
vector=Array.new
vector2=Array.new
j=0


#Sentencias que hay que añadir para hacer funcionar la BD
#Le indicamos que se ejecutará en nuestro PC por el puerto 80
#Además le indicamos el login y contraseña
existapi = ExistApi.new('/exist/xmlrpc','localhost',8080)
existapi.set_credentials('admin','cristina')


#Otras sentencias opcionales relacionadas con la libreria Ruby
existapi.param_indent = 'no'
existapi.param_encoding = 'UTF-8'
existapi.param_highlight_matches = 'none'


#Lo primero de todo es comprobar que se han introducido dos argumentos
if (param1 == nil || param2 == nil)

#Si no lo ha hecho se lo indicamos al usuario
puts "¡Sentencia incorrecta! Lea las instrucciones siguientes:"
puts "----------------------------------------------------------------------"
puts "Para mostrar:\n*todos los equipos escriba: ruby p7final.rb todos equipos"
puts "*todos los jugadores de un equipo escriba: ruby p7final.rb todos [equipo]"
puts "*todos los jugadores de todos los equipos escriba: ruby p7final.rb todos todos"
puts "*un jugador de un equipo: ruby p7final.rb [equipo] [portero|defensa|centrocampista|delantero]"
puts "*los tecnicos de un equipo: ruby p7final.rb [equipo] tecnico"

#---------------------------------------------------------------------------

#Si el usuario desea conocer todos los equipos y/o todos los jugadores
elsif (param1 == "todos" )

#Ahora debemos comprobar el segundo parámetro
#Si quiere conocer TODOS los equipos de la liga o los jugadores de TODOS los equipos
if(param2 == "equipos" || param2 == "todos")

#Nos debemos bajar todas las colecciones de la carpeta equipos en la BD
archivo1=existapi.get_document('/equipos/rmadrid.xml')
archivo2=existapi.get_document('/equipos/barca.xml')

#Creamos los documentos
ficheros.push(Document.new(archivo1))
ficheros.push(Document.new(archivo2))

#Ponemos un titulo a la lista
puts "Los equipos de la liga española son:"
puts "------------------------------------------"

#//////////////////////////////////////////////////////////////////////////////
#TODOS LOS EQUIPOS DE LA LIGA
if(param2=="equipos")
#En este caso solo mencionamos el nombre del equipo
ficheros.each do |teams|
XPath.each(teams,"//equipo/@id") { |equipo|
puts "***-"+equipo.value}
end#Final del bucle

#TODOS LOS JUGADORES DE TODOS LOS EQUIPOS
elsif(param2=="todos")
ficheros.each do |teams|
#Primero ponemos el nombre del equipo
XPath.each(teams,"//equipo/@id") { |equipo|
puts ""
puts "***-"+equipo.value
puts "--------------------"}
#Y luego sus jugadores
XPath.each(teams,"//jugador") { |jugadores|
puts "*-"+jugadores.text

}
end#Final del bucle
end
#//////////////////////////////////////////////////////////////////////////////

end


#//////////////////////////////////////////////////////////////////////////////
#TODOS LOS JUGADORES DE UN EQUIPO

#Primero averiguamos el equipo de que se trata

case param2
when "RMadrid"
arc = existapi.get_document('/equipos/rmadrid.xml')
when "Barca"
arc = existapi.get_document('/equipos/barca.xml')
end

#Y mostramos los jugadores por pantalla indicando además su posicion en el campo
doc = Document.new(arc)

#Obtenemos los jugadores y los almacenamos en un array
XPath.each(doc,"//jugador") { |jugadores|
vector.push(jugadores.text)
}
#Obtenemos su posicion
XPath.each(doc,"//jugador/@tipo") { |titulo|
vector2.push(titulo.value)
}

#Los mostramos de forma alterna
vector.each do |num|
#Debemos pasar el String a integer
numero=num.to_i
#Salida por pantalla
puts "*-"+vector[numero+j]+ " ( "+vector2[numero+j]+" )"
j=j+1
end


#//////////////////////////////////////////////////////////////////////////////


else
#Si pregunta por algun jugador en particular


#NOMBRE DE JUGADORES SEGUN SU POSICION Y EQUIPO
if (param1 == "RMadrid")
archivo=existapi.get_document('/equipos/rmadrid.xml')
elsif (param1 == "Barca")
archivo=existapi.get_document('/equipos/barca.xml')
end

#Creamos el documento
doc = Document.new(archivo)
#Obtenemos la posicion del jugador
tipo = param2


#//////////////////////////////////////////////////////////////////////////////
#LISTAR LOS JUGADORES O LOS TECNICOS

case tipo

when "defensa","centrocampista","delantero","portero"
XPath.each(doc,"//jugador[@tipo=\""+tipo+"\"]/") { |titulo|
puts "*-"+titulo.text }
when "tecnico"
#XPath.each(doc,"//"+tipo) { |titulo|
#puts "*-"+titulo.text }

#Obtenemos los jugadores y los almacenamos en un array
XPath.each(doc,"//"+tipo) { |tecnico|
vector.push(tecnico.text)
}
#Obtenemos su posicion
XPath.each(doc,"//"+tipo+"/@tipo") { |tecn|
vector2.push(tecn.value)
}

#Los mostramos de forma alterna
vector.each do |num|
#Debemos pasar el String a integer
numero=num.to_i
#Salida por pantalla
puts "*-"+vector[numero+j]+ " ( "+vector2[numero+j]+" )"
j=j+1
end

end#Fin del case


end#Fin del if principal

Pruebas:

Taller3: Bloque T3.2

1.Hacer una petición a twitter de las últimas líneas de status de los "amigos".

Este ejercicio lo hicimos en clase. Hacemos una petición http usandio la API de Twitter y se devuelve el resultado en formato xml. Hicimos uso de la funcion friends_timeline que nos devueve los últimos 20 status de nuestros amigos.Hacemos POST porque no enviamos información, sino que la recibimos.

#!/usr/bin/perl

use LWP::UserAgent;
use HTTP::Request::Common qw(POST GET);
use XML::Simple;
my $ua = LWP::UserAgent->new();
my $request = GET 'http://aap_ugr:ugr_aap@twitter.com/statuses/friends_timeline.xml';
my $res = $ua->request($request);
my $cont = XMLin($res->content);

for my $resultado ( %{$cont->{'status'}} ) {
print $resultado->{'text'},"\n";
}

Taller3: Bloque T3.1

1. Argumentar la utilidad de los servicios web y qué posibilidades tienen en el futuro.

Un servicio web (en inglés, Web service) es un conjunto de protocolos y estándares que sirven para intercambiar datos entre distintas aplicaciones desarrolladas en lenguajes de programación diferentes, y ejecutadas sobre cualquier plataforma (interoperatibidad).

Las ventajas que ofrecen son:

• Los servicios Web fomentan los estándares y protocolos basados en texto, que hacen más fácil acceder a su contenido y entender su funcionamiento.
• Al apoyarse en HTTP, los servicios Web pueden aprovecharse de los sistemas de seguridad firewall sin necesidad de cambiar las reglas de filtrado.
• Permiten que servicios y software de diferentes compañías ubicadas en diferentes lugares geográficos puedan ser combinados fácilmente para proveer servicios integrados.
• Permiten la interoperabilidad entre plataformas de distintos fabricantes por medio de protocolos estándar y abiertos. Las especificaciones son gestionadas por una organización abierta, la W3C, por tanto no hay secretismos por intereses particulares de fabricantes concretos y se garantiza la plena interoperabilidad entre aplicaciones.

La principal razón para usar servicios Web es que se basan en HTTP sobre TCP (Transmission Control Protocol) en el puerto 80. Dado que las organizaciones protegen sus redes mediante firewalls que filtran y bloquean gran parte del tráfico de Internet-, cierran casi todos los puertos TCP salvo el 80, que es, precisamente, el que usan los navegadores. Los servicios Web utilizan este puerto, por la simple razón de que no resultan bloqueados.

Otra razón es que, antes de que existiera SOAP, no había buenas interfaces para acceder a las funcionalidades de otros ordenadores en red. Las que había eran ad-hoc y poco conocidas, tales como EDI (Electronic Data Interchange),RPC (Remote Procedure Call), u otras APIs.

Una tercera razón por la que los servicios Web son muy prácticos es que pueden aportar gran independencia entre la aplicación que usa el servicio Web y el propio servicio. De esta forma, los cambios a lo largo del tiempo en uno no deben afectar al otro. Esta flexibilidad será cada vez más importante, dado que la tendencia a construir grandes aplicaciones a partir de componentes distribuidos más pequeños es cada día más utilizada.

Se espera que para los próximos años mejoren la calidad y cantidad de servicios ofrecidos basados en los nuevos estándares.

Unos enlace que he encontrado con noticias de interes son:

http://www.moviendonos.com/categoria/servicios-web

http://www.maestrosdelweb.com/editorial/servicios-web/page/2/

Exist

Tras descararlo en este enlace e instalar los paquetes java requeridos (jre,jdk) escribo en el terminal -jar eXist-1.2.5-rev8668.jar . Ahora tras ejecutarlo voy al navegador y escribo
http://localhost:8080/exist/index.x. Luego he introducido el login admin y mi contraseña y nos sale:

Taller2: Bloque T2.12

1. Poner la expresión XPath que en el XML de la cassa imprima los nodos que tengan puerta a una habitacion determinada

El código XML:
micasa>
habitacion id="cuarto de baño">
mueble>aparador< /mueble>
mueble>bañera< /mueble>
puerta a="pasillo">
/habitacion>
habitacion id="pasillo">
mueble>cuadro< /mueble>
puerta a="cuarto de baño">
puerta a="dormitorio">
< /habitacion>
< /micasa>

El código en Ruby es:

#!/usr/bin/ruby

require 'rexml/document'
include REXML
documento = ARGV[0]
habitacion = ARGV[1]
file = File.new(documento)
doc = Document.new(file)
XPath.each(doc,"//puerta[@a=\""+habitacion+"\"]/..") { |habitaciones|
puts "*"+habitaciones.attribute('id').to_s
}

Con esto le decimos: que busque las puertas de una habitación pasada como parámetro (gracias al atributo @a). Luego pasa a cadena de caracteres el identificador de las habitaciones y lo muestras por pantalla.Ejemplo:

ruby ./ejer212a.rb pasillo
*cuarto de baño


2.Imprimir de un documento XML con los equipos de futbol los que estén clasificados para la liga de campeones

Documento en Ruby:

#!/usr/bin/ruby

require 'rexml/document'
include REXML
documento = ARGV[0]
file = File.new(documento)
doc = Document.new(file)

#Buscamos los equipos que tengan una posicion en la lista menos o igual que 4
XPath.each(doc,"//equipo[position()<=4]") { |equipos|
puts "*"+equipos.text
}

Documento en XML

champion>
equipo posicion="1"> Olula del Rio/equipo>
equipo posicion="2"> Real Madrid/equipo>
equipo posicion="3"> Almeria/equipo>
equipo posicion="4"> Granada/equipo>
equipo posicion="5"> Olula/equipo>
equipo posicion="6"> Betis/equipo>
equipo posicion="7"> Barca/equipo>
/champion>

Ejemplo:

ruby ./ejer212b.rb champion.xml
* Olula del Rio
* Real Madrid
* Almeria
* Granada

Taller2: Bloque T2.11

1. Realiza una quiniela AJAX, que al modificar el resultado de un partido lo almacene en el servidor

En primer lugar creamos el documento html donde se introduciran los equipos así como el resultado del partido.
Luego creo el cliente en Javascript que llama al servidor con una interfaz REST.

El servidor escrito en ruby toma el documento quiniela.xml de y lo va actualizando:


#!/usr/bin/ruby
require 'rexml/document'
require 'cgi'
include REXML

#Cabecera, poner siempre
print "Content-Type: application/xhtml+xml\n\n"

cgi = CGI.new()

#Recojo los parámetros que le paso por la interfaz res
nPartido=cgi['nPartido']
resultado=cgi['resultado']
local=cgi['local']
visitante=cgi['visitante']


# Comprobamos que se han rellenado todas las casillas
if((nPartido=="" || resultado=="" || local =="" || visitante==""))
print "Te falta algun dato por introducir \n\n "
nPartido=-1;
end

# Construimos documento XML
file = File.new('./quiniela.xml','r')
doc = Document.new(file)

# Guardamos el nuevo documento XML con las modificaciones efectuadas
file = File.new('./quiniela.xml','w')
file.print <<"EOF"
EOF
print <<"EOF"
EOF

#Comenzamos a escribir nuestro fichero
file.print ""

#Buscamos todos los partidos
i = 0;
doc.root.each_element('partido') { |p|

#if(p.attributes['equipoLocal']==local.to_s && p.attributes['equipoVisitante']==visitante.to_s)
#Si ya estaba en la quiniela cambio solo el resultado
#p.attributes['resultado']=resultado

#Si coincide con el numero de partido y el resultado es correcto
if(i==nPartido.to_i && (resultado.to_i=='1' ||resultado.to_i=='2' ||resultado.to_i=='x' ||resultado.to_i=='X'))

#Sobreescribimos el partido
#En caso contrario se deja tal y como esta
p.attributes['resultado']=resultado
p.attributes['equipoVisitante']=visitante
p.attributes['equipoLocal']=local
end

#Escribimos todos los partidos
file.print p,"\n"
print p,"\n"
i+=1
}
file.print""
file.print ""
print ""

Práctica 6: Programa AJAX

Para la práctica he creado un programa basado en feeds. En él puedes tanto visitar algunos que te propongo, como almacenar los que te gusten. Además, como extensión le añadí un apartado para telecos que quieran informarse sobre su plan de estudios almacenado que es leído deen un fichero .xml.

Ficheros:
1. Cliente
2. Servidores:
El primero escrito en Perl

#!/usr/bin/perl

use CGI qw(:standard);
use XML::RSS;
use LWP::Simple qw(get);

my $numero_elementos = param('num_elementos');
my $url = param('url');
#Baja fichero
my $rdf = get($url);
my $rss = new XML::RSS;
$rss->parse($rdf);
my $rss_salida = new XML::RSS;
$rss_salida->channel( title => 'Resumen feed',
link => $url,
description => 'Resumiendo el feed' );
print header( -type => 'application/xhtml+xml' );

for (my $i = 0; $i < $numero_elementos;$i ++ ) {
$rss_salida->add_item( title => $rss->{'items'}[$i]->{'title'},
link => $rss->{'items'}[$i]->{'link'},
description => $rss->{'items'}[$i]->{'description'});
}
print $rss_salida->as_string;

El segundo escrito en Ruby:

#!/usr/bin/ruby
require 'rexml/document'
require 'cgi'
include REXML

cgi = CGI.new()
print""
#Recojo los parámetros que le paso por la interfaz res
curso=cgi.params['curso'][0]

print "Content-Type: application/xhtml+xml\n\n"

# Construimos documento XML
file = File.new('teleco.xml','r')
doc = Document.new(file)

print ""

#Busco dentro del documento el curso concreto y obtengo el contenido de las asignaturas que corresponden con el tipo buscado
doc.root.each_element(curso.to_s) { |c|
c.each_element('asignatura'){ |a|
print a,"\n" #Imprimo la asignatura que estaba buscando
}
}
print""
print""



Podemos probarlo en esta direccion