Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Taller: Integración de Moodle con sistemas externos (Web services)

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 24 de febrero de 2010 por EducaMadrid

4249 visualizaciones

Taller de la la Moodle Moot Madrid 09 titulado "Integración de Moodle con sistemas externos (Web services)" realizado por Marc Alier, Jordi Piguillem y Miguel Angel Conde.

Más información Transcripción

Descargar la transcripción

Buenos días a todos 00:00:00
Benvindos ao taller de webservices 00:00:03
Marc Calier e Jordi Pirillán están chegando 00:00:05
Sabéis o que é o tráfico en Madrid e estas cosas 00:00:08
Darles un pouco de respiro 00:00:11
E perdonarles este retraso 00:00:13
Eu vou começar, meu nome é Miguel Ángel Conde 00:00:15
Tambén estamos nós, David Castro 00:00:17
Que nos vai apoiar en toda a parte de un experimento 00:00:18
Na parte experimental do taller que vamos ver 00:00:21
Bien 00:00:24
Os puntos que vamos ver 00:00:25
Ván a ser unha breve introducción 00:00:27
Hablaremos un pouco dos servizos 00:00:28
Da arquitectura dos servizos en Moodle 00:00:30
Como se planteou esa arquitectura dos servizos 00:00:32
Que aplicacións poden aportar esos servizos 00:00:34
E por último, será un experimento 00:00:36
Bien 00:00:39
Se empezamos a hablar de servizos 00:00:40
Eu non digo de servizos web 00:00:41
Eu digo de servizos 00:00:42
A todo o mundo pode considerar 00:00:44
A necesidade de poder utilizar algo 00:00:46
Que dentro de un sistema 00:00:48
Para cualquier outro propósito 00:00:49
Que non seja o que inicialmente previsto 00:00:50
Ou o que inicialmente considerado 00:00:53
Quer dizer, nós temos un sistema 00:00:55
Que nos aporta unha potencia enorme 00:00:57
E queremos que esa potencia enorme 00:00:59
Non só se dê dentro de ese sistema 00:01:00
Só que se dê en cualquier outro propósito 00:01:02
Hoje em dia, cada vez son máis 00:01:04
O planteamento, a creación de sistemas 00:01:06
Según arquitecturas orientadas a servizos 00:01:08
Quer dizer, non buscamos prover unha tecnologia 00:01:10
Non buscamos prover algo 00:01:12
Que funcione só para unha cosa 00:01:14
Buscamos prover un servizo 00:01:16
E ademais un servizo que sea portable 00:01:17
Que sea multiplataforma 00:01:19
Que sea escalable 00:01:21
Que poda crecer dentro de unha arquitectura 00:01:22
Ademais que sempre nos permite unha flexibilidade 00:01:25
Que non nos anclemos en algo determinado 00:01:28
Teniendo en cuenta todo ese contexto 00:01:31
Nos podemos poner a pensar agora en os LMS 00:01:33
En as plataformas de aprendizaje 00:01:36
Ben, seja modelo, ben seja cualquera 00:01:38
Que nos aportan? 00:01:40
Nos aportan un conjunto de funcionalidades 00:01:41
E un conjunto de funcionalidades 00:01:43
Que podrían aplicarse a moitos outros contextos 00:01:45
En concreto, se nos ponemos a pensar 00:01:50
En las plataformas de aprendizaje 00:01:52
Por ejemplo, nos poden proporcionar alta de usuario 00:01:54
Nos poden proporcionar gestión de cursos 00:01:56
Nos poden proporcionar gestión de contenidos 00:01:58
Todos esos servizos 00:02:00
Podríamos utilizarlos dentro de outros contextos 00:02:02
Podríamos utilizarlos dentro de dispositivos móviles 00:02:04
Podríamos utilizarlos dentro 00:02:06
O combinado con herramientas de la COFIS 00:02:08
En cuantos sitios non habéis visto? 00:02:10
A cuantas personas non habéis visto? 00:02:12
Tratando de integrar el alta de los alumnos en Moodle 00:02:14
Con otro tipo de sistema 00:02:16
Por ejemplo 00:02:18
Decir, non é que eu quero algo que sea transparente 00:02:19
Ademais, quero que me logue unha única vez 00:02:21
Y poder entrar a meus cursos 00:02:23
Pero que realmente tenga outro segundo sistema 00:02:25
Que estamos buscando? 00:02:27
Estamos buscando un servicio 00:02:29
Un servicio que Moodle nos proporciona 00:02:31
E que, ademais, queremos poderlo utilizar en outros contextos 00:02:33
Por poner outros exemplos 00:02:35
Podríamos ver técnicas de visualización de la información 00:02:37
Sobre información que nos proporcione la plataforma de aprendizaje 00:02:39
Podríamos considerar 00:02:41
Seguimiento de un curso 00:02:43
Podríamos considerar extracción de contenidos 00:02:45
Para su utilización en cualquier otro contexto 00:02:47
Lo que se busca 00:02:49
Es dar esa potencialidad 00:02:51
Pero non solo limitado a un punto 00:02:53
Sino que, ademais 00:02:55
Lo que queremos es poderlo exportar 00:02:57
Poderlo utilizar en cualquier outro contexto 00:02:59
Poderlo utilizar 00:03:01
En lugares donde inicialmente non estaba previsto 00:03:03
Bien 00:03:07
Hablando de todo esto 00:03:09
Habréis oído hablar alguna vez de los servicios web? 00:03:11
Os suenan los servicios web? 00:03:13
Cuantos de aquí sois programadores? 00:03:15
Cuantos de aquí sois programadores? 00:03:17
Bien, esto será útil 00:03:19
Cuantos habéis programado servicios web? 00:03:21
Bueno, algo es algo 00:03:23
Bien 00:03:25
Lo digo sobre todo por el experimento posterior 00:03:27
Bien 00:03:29
Sobre todo la idea 00:03:31
De lo que se busca con un servicio 00:03:33
Es independizar la implementación que haya subyacente 00:03:35
Con respecto a la funcionalidad 00:03:37
Que se está proporcionando 00:03:39
A nosotros nos dan una interfaz 00:03:41
Nos dan una API 00:03:43
Que nos permite repasar estos parámetros 00:03:45
Como lo haga internamente 00:03:47
Queremos esa capacidad de encapsulamiento 00:03:49
Esa capacidad de abstracción 00:03:51
Y también no generar unas dependencias 00:03:53
Que nos obligarían a utilizar un contexto determinado 00:03:55
Bien, en cualquiera de los casos 00:03:57
Esos servicios se transforman en servicios web 00:03:59
Y mediante diferentes tipos de tecnologías 00:04:01
Diferentes tipos de protocolos 00:04:03
Podremos ver unos conectores 00:04:05
Podremos ver 00:04:07
Que existen diferentes protocolos 00:04:09
En la web para poder llevar a cabo esto 00:04:11
Los protocolos son necesarios 00:04:13
No podemos poner simplemente el servicio web a funcionar y se acabó 00:04:15
No podemos decir 00:04:17
Es que yo pongo una función y eso es suficiente 00:04:19
No, necesitamos un protocolo 00:04:21
Necesitamos hacerlo de una manera apropiada 00:04:23
Necesitamos poder hacer eso de una forma escalable 00:04:25
Que además luego nos permita utilizarlo en otros sitios 00:04:27
Porque sino no estaríamos haciendo nada 00:04:29
Estaríamos haciendo una API con un conjunto de funciones y se acabó 00:04:31
Bien, vosotros sois programadores 00:04:33
Y habéis programado en Moodle, ¿verdad? 00:04:35
Os habéis encontrado 00:04:37
Un problema, yo creo que si 00:04:39
Podemos definir algún tipo de actividad 00:04:41
O un módulo o alguna aplicación externa Moodle 00:04:43
Que utilice Moodle 00:04:45
¿Qué pasa cuando cambiamos de versión? 00:04:47
Pues que la mayor parte de las veces 00:04:51
Nos cambian el modelo de datos, los valores o lo que sea 00:04:53
Y se va todo al carajo 00:04:55
Bien, ¿qué es lo que estamos intentando hacer? 00:04:57
Lo que vamos a intentar hacer es proveer 00:04:59
Una API, un conjunto de funciones 00:05:01
Que se invocarán a través de una serie de conectores 00:05:03
En forma de servicios web 00:05:05
Y que nos devolverán una información 00:05:07
Que harán que seamos independientes 00:05:09
Del tipo de versión, por ejemplo, que se vaya 00:05:11
Esto es fundamental 00:05:13
Lo que se ha comprometido el equipo de Moodle 00:05:15
Es mantener una API externa 00:05:17
Que podrá irse ampliando 00:05:19
Y que nos permitirá hacer eso a través de diferentes versiones 00:05:21
Moodle se encargará de implementar 00:05:23
Las diferentes funciones 00:05:25
Y por ello sabrán como lo harán 00:05:27
Y nos devolverán el valor, el retorno de esas funciones 00:05:29
Independientemente de que hayan cambiado 00:05:31
El modelo de datos o no, eso no nos importa 00:05:33
Nosotros podremos seguir invocando 00:05:35
A los servicios web exactamente de la misma manera 00:05:37
Esa es sobre todo la idea 00:05:39
Con eso, ¿qué estamos evitando? 00:05:41
Que yo, por ejemplo, haya hecho un módulo 00:05:43
Buenísimo para hacer 00:05:45
Cualquier tipo de gestión 00:05:47
Que cambien la versión y me metan los roles 00:05:49
Que supongo que a todo el mundo le habrá pasado 00:05:51
En el momento que surgieron los roles en Moodle 00:05:53
Y que digamos 00:05:55
Ya no me funciona nada 00:05:57
Vamos a intentar 00:05:59
Mediante este tipo de sistemas 00:06:01
Que dejemos de tener este tipo de frustraciones 00:06:03
Y de tener que cambiar muchísimo código 00:06:05
Que no solamente es en cuanto a 00:06:07
Como nos sentimos nosotros, sino que es tiempo y dinero 00:06:09
En muchas ocasiones 00:06:11
Bien, pues a través de este tipo de tecnologías 00:06:13
Lo que buscaremos es eso 00:06:15
Por una parte 00:06:17
Y por otra parte tendremos que plantear 00:06:19
Una API, un conjunto de funciones 00:06:21
Lo suficientemente bien fundamentado 00:06:23
Para que eso pueda crecer 00:06:25
Es decir, no podemos decir 00:06:27
Ahora planteo una arquitectura de servicios web como quieras 00:06:29
Vamos a ser un poquito organizados 00:06:31
En la manera correcta y vamos a hacerlo 00:06:33
De acuerdo con las especificaciones 00:06:35
Que se dan en Moodle 00:06:37
Con Moodle se trabaja todos los días 00:06:39
Se acuerdan las interfaces para los servicios 00:06:41
Se acuerdan las funciones y se acuerdan parámetros de seguridad 00:06:43
Claro, si alguien 00:06:45
Supongo que nadie estará involucrado 00:06:47
Ahora mismo en el desarrollo de servicios web 00:06:49
Nosotros estamos, pues está la UPC 00:06:51
Está la Universidad de Salamanca 00:06:53
Y están algunas empresas también de Barcelona 00:06:55
Pues en este desarrollo 00:06:57
Nos estamos pegando 00:06:59
En muchas ocasiones 00:07:01
Con Peter Skoda, con Martin Gullamas 00:07:03
Determinando qué hacer, qué no hacer 00:07:05
Cómo hacerlo con seguridad, cómo no hacerlo 00:07:07
Es decir, ahora mismo existe un conjunto de servicios web 00:07:09
Nosotros veremos un pequeño cliente 00:07:11
Que ataca los servicios web 00:07:13
Para crear cursos y para crear usuarios 00:07:15
Es lo que vais a probar 00:07:17
Pero sobre todo tenemos que entender 00:07:19
Que este tipo de elementos 00:07:21
Va a cambiar y que ahora mismo 00:07:23
No está establecida la base 00:07:25
Con lo cual, igual hoy tenemos una porción de código funcional 00:07:27
Y mañana han cambiado ciertos parámetros de seguridad 00:07:29
Y tenemos que cambiarlo 00:07:31
Tenemos, hasta que no esté esa primera versión 00:07:33
Disponible, tenemos que ser cautos 00:07:35
Sobre todo en los desarrollos que llevamos a cabo 00:07:37
Actualmente 00:07:39
Existen un conjunto de servicios web 00:07:41
Backporteados para la versión 1.9 00:07:43
Y un conjunto de servicios web para la 2.0 00:07:45
Que es en el que más está trabajando 00:07:47
Bien 00:07:49
Dentro de esto, como os he dicho 00:07:51
Tenemos que plantear un modelo arquitectónico 00:07:53
Es decir, no podemos programar servicios web 00:07:55
Sin más 00:07:57
Bien, este modelo arquitectónico 00:07:59
Costaría en principio de tres capas 00:08:01
Puede ser que se varíen 00:08:03
Pero por ahora constaría de tres capas 00:08:05
Dentro de ellas tendríamos los conectores más famosos 00:08:07
Con los diferentes protocolos de conexión 00:08:09
Que se pueden hacer a servicios web 00:08:11
Por ejemplo, tendríamos REST 00:08:13
Tendríamos XMLRPC, tendríamos SOAP 00:08:15
¿Podrían añadirse más? 00:08:17
Sí, la idea es tener una arquitectura lo suficientemente flexible 00:08:19
Para que seamos capaces 00:08:21
De poder añadir cualquier tipo de protocolo adicional 00:08:23
De hecho, existen protocolos de interoperabilidad 00:08:25
Luego veremos en posibles aplicaciones 00:08:27
Que es maravilloso lo que se puede llegar a hacer 00:08:29
Podemos llegar a integrar 00:08:31
Una aplicación dentro de Moodle 00:08:33
Y podemos extraer información 00:08:35
De aplicaciones de Moodle 00:08:37
A nuestro sistema 00:08:39
Es decir, lo que vamos a proporcionar con esto 00:08:41
Vamos a proporcionar unas tecnologías de conexión 00:08:43
Que realmente nos permitan 00:08:45
Desvincularnos un poco de Moodle 00:08:47
E intercambiar información con él 00:08:49
De una manera coherente y que entienda 00:08:51
Por ejemplo 00:08:53
Podríamos crear un conector 00:08:55
Para el protocolo IMS LTI 00:08:57
No sé si conocéis ese protocolo 00:08:59
Es un protocolo de interoperabilidad 00:09:01
Que permitiría la integración 00:09:03
Por ejemplo, de herramientas externas 00:09:05
Dentro de Moodle 00:09:07
Por otra parte, tendríamos una segunda capa 00:09:09
Tendríamos una segunda capa 00:09:11
Que esos conectores llamarán 00:09:13
Esta segunda capa lo que provee 00:09:15
Es un conjunto de funciones 00:09:17
Que van a permitir comunicarnos 00:09:19
En el core de Moodle 00:09:21
Pero sin que nosotros sepamos nada 00:09:23
Será como esa API externa 00:09:25
Esa información que necesitemos utilizar 00:09:27
Y luego, por otro lado, tendremos 00:09:29
Lo que serían las bibliotecas de Moodle 00:09:31
Esto no lo vamos a tocar 00:09:33
Esto nos lo va a dar Moodle 00:09:35
Va a ser algo que se va a mantener 00:09:37
Algo que no va a cambiar demasiado 00:09:39
Esto no nos importará demasiado 00:09:41
Como también ya que el external 00:09:43
Lo que hará será envolver ese conjunto de funciones 00:09:45
Para poder llevar a cabo todo esto 00:09:47
Esas funciones que dependerán 00:09:49
De lo que vaya por debajo 00:09:51
Pero que a nosotros nos da igual 00:09:53
Nosotros nos podremos conectar 00:09:55
Utilizando ese tipo de conectores 00:09:57
De una manera totalmente transparente 00:09:59
A nuestro sistema 00:10:01
Bien, y ahora el señor Pidillén 00:10:03
Va a comentaros como se llevan a cabo 00:10:05
Este tipo de conexiones 00:10:07
Y luego volveremos con respecto 00:10:09
A las posibles utilidades 00:10:11
Que se le pueden dar a este tipo de servicios 00:10:13
Bien, como se haría esto 00:10:15
Normalmente el usuario 00:10:17
Lo que haría es desde un cliente determinado 00:10:19
Pasaría un usuario y un password 00:10:21
Se logaría 00:10:23
En principio solo tendría que logarse una vez 00:10:25
Porque lo que haría el sistema es devolverle un token 00:10:27
A partir de ese token podría interactuar con el sistema 00:10:29
Sin tener que estar intercambiando constantemente 00:10:31
Usuario y contraseña 00:10:33
Con lo cual se gana rápido 00:10:35
Se gana en el tamaño que pueda tener la conexión 00:10:37
Y no solamente en eso, se gana en seguridad 00:10:39
Si pasas cinco veces la contraseña 00:10:41
Es más fácil que te la puedan desencriptar que si la pasas una 00:10:43
Bien, después una vez teniendo ese token 00:10:45
Lo que haremos será invocar una determinada función 00:10:47
O un determinado módulo 00:10:49
De una parte del external 00:10:51
Con una serie de parámetros y con su nombre 00:10:53
Eso iría otra vez contra el servidor 00:10:55
Y lo que haría sería ejecutar o devolver 00:10:57
La información que fuera adecuada 00:10:59
En función de, bueno, utilizando 00:11:01
El conector 00:11:03
Que lo vayamos a considerar 00:11:05
Bien sea SOAP, bien sea REST, el que sea 00:11:07
A partir de aquí se ejecutaría 00:11:09
Se buscaría esa información dentro del servidor 00:11:11
Y esa información se devolvería 00:11:13
A través del servicio web 00:11:15
Y llegaría a lo que es el cliente PHP 00:11:17
Bien, si hablamos además 00:11:21
De las posibles aplicaciones 00:11:23
Que tienen los servicios web 00:11:25
Dentro de estas 00:11:27
Dentro de las posibles tecnologías existentes 00:11:29
Tendríamos 00:11:31
Hola, buen día 00:11:37
Buenos días 00:11:39
La introducción la tenía yo y Miguel Ángel 00:11:41
Se ha portado muy bien, empezaba antes de que llegáramos 00:11:43
Porque teníamos que desayunar 00:11:45
Y esas cosas 00:11:47
Ayer fue muy largo, desde cinco de la mañana 00:11:49
A una de la madrugada 00:11:51
Y esta mañana las horas se han pegado 00:11:53
Una pregunta 00:11:55
¿Cuantos de vosotros sois programadores? 00:11:57
Vale 00:11:59
Está claro 00:12:01
No sé si hasta que punto 00:12:03
Lo has contado 00:12:05
Que son los web services y que no son 00:12:07
¿Tenemos claro que no son? 00:12:11
Los web services no son algo 00:12:15
Que vayamos a utilizar como usuarios 00:12:17
Es algo que va a permitir que construyamos cosas encima 00:12:19
¿Vale? 00:12:21
Una de las cosas importantes a tener en cuenta 00:12:23
De esta arquitectura 00:12:25
Que hemos conseguido 00:12:27
Que Moodle moviera ficha el año pasado 00:12:29
Para implementar 00:12:31
Es primero que va a resolver un problema que ya tenemos 00:12:33
Que son todos los que hemos hecho 00:12:35
Integraciones contra Moodle 00:12:37
Hacer matriculaciones, crear cursos 00:12:39
Inscribir alumnos en cursos 00:12:41
Y cargar algunos materiales automáticamente 00:12:43
Empalmándolo con los softwares 00:12:45
Que ya tenemos cada uno, algunos privados 00:12:47
Algunos libres 00:12:49
Pero hemos tenido que hacer estas cargas manualmente 00:12:51
Esto hemos tenido que hacer los técnicos 00:12:53
Rascando en plan coraje 00:12:55
Y tocando las tablas 00:12:57
Y cada vez que en Moodle nos han liberado una versión 00:12:59
O una subversión, muchas cosas se han roto 00:13:01
La idea es que 00:13:03
Esta capa de web services 00:13:05
Se compromete a que 00:13:07
Al menos el equipo de core 00:13:09
Se compromete a que se mantenga relativamente estable 00:13:11
Va a permitir que 00:13:13
Cuando nos enchufemos 00:13:15
Cambiemos el desarrollo 00:13:17
Que los desarrolladores tendrán que volver a cambiar 00:13:19
Y adapten sus aplicaciones de backoffice contra esto 00:13:21
Esto no cambie 00:13:23
La idea sobre todo es 00:13:25
La idea que ya teníamos el año pasado 00:13:27
Era decir, queremos que la migración 00:13:29
A Moodle 2.0 sea poco dolorosa 00:13:31
Porque ya va a ser dolorosa 00:13:33
Porque hay algunas cosas que van a cambiar 00:13:35
Y cuando los usuarios nos cambian las cosas del sitio 00:13:37
Siempre nos quejamos, aunque luego nos guste 00:13:39
Pero primero es quejarse 00:13:41
Imaginamos si encima la migración va a ser 00:13:43
Dolorosa por parte de sistemas 00:13:45
Entonces 00:13:47
Por eso en Moodle 2.0 se están haciendo los web services 00:13:49
Pero también 00:13:51
Sobre todo desde el equipo de la Universidad de Salamanca 00:13:53
Y CLEI están backporteando 00:13:55
Están backporteando 00:13:57
Los web services a 1.9 00:13:59
De forma que podremos 00:14:01
La migración que vamos a hacer hoy 00:14:03
Contra Moodle 2.0 en la máquina de Piggy 00:14:05
Pues se podrá hacer 00:14:07
Funcionar contra un Moodle 1.9 00:14:09
Con los web services montados 00:14:11
Y entonces cuando tengamos que emigrar 00:14:13
De 1.9 a 2.0 00:14:15
Con un poco de suerte funcionará todo 00:14:17
A la primera y sino tendremos que tocar 00:14:19
Algunas pocas cosas 00:14:21
Porque de alguna forma la migración sea poco dolorosa 00:14:23
Y de alguna forma podamos invertir 00:14:25
En software de sincronización potente 00:14:27
Ya que permanezca 00:14:29
Esta es una línea 00:14:31
La otra línea es desde la línea 00:14:33
De la gente que dice 00:14:35
No, no, es que yo estoy más preocupado 00:14:37
En que cuando yo aplico mi docencia con Moodle 00:14:39
Es que yo tengo profesores que quieren usar 00:14:41
Google Docs 00:14:43
O ahora hay algún cafre que quiere usar Google Wave 00:14:45
O yo quiero tener 00:14:47
Un grupo de fotografías en Flickr 00:14:49
Que son las fotografías de los alumnos 00:14:51
O yo quiero tener 00:14:53
Google Maps 00:14:55
Pues como integro este tipo de cosas 00:14:57
La gente que dice no, no, es que yo tengo gente 00:14:59
Que tiene auténticos problemas de accesibilidad 00:15:01
Y quiero acceder al curso de Moodle 00:15:03
Con unas limitaciones 00:15:05
De accesibilidad terribles 00:15:07
Y a ver, todo el que tenga 00:15:09
Un teléfono móvil se da cuenta 00:15:11
De lo difícil que es acceder a Moodle 00:15:13
Un teléfono móvil con navegador web 00:15:15
Ve lo poco accesible que es Moodle 00:15:17
Porque cuando tienes una pantalla pequeñita 00:15:19
Moodle cuesta mucho de trabajar 00:15:21
Entonces la idea es que además 00:15:23
Tenemos un proyecto funcionando 00:15:25
La idea es sacar la información 00:15:27
De los web services 00:15:29
No únicamente los datos que tenemos 00:15:31
En administración 00:15:33
Grupos, cursos, permisos 00:15:35
Asignaciones, que esto es lo que interesa al centro 00:15:37
Y es digamos el argumento de venta 00:15:39
La idea es que también vamos a sacar 00:15:41
La información del curso por los web services 00:15:43
Y vamos a sacar la información que hay en los foros 00:15:45
Y que hay en los wikis 00:15:47
Y también vamos a meter funciones 00:15:49
Que permitan que alguien desde fuera 00:15:51
Añada información al foro 00:15:53
O alguien añada un comentario 00:15:55
O alguien envíe algún fichero 00:15:57
Por ejemplo podemos hacer unha actividad 00:15:59
Que consiste en hacer unha fotografía 00:16:01
Desde un teléfono móvil 00:16:03
Y envíarla directamente al Moodle 00:16:05
Todas estas cosas se podrán desarrollar 00:16:07
Pero lo más importante 00:16:09
Se podrán desarrollar de forma que quepan 00:16:11
En las instalaciones oficiales de Moodle 00:16:13
Porque no va a afectar a los servidores 00:16:15
Todas as cosas nuevas 00:16:17
Se poden montar en servidores 00:16:19
Más o menos de pruebas 00:16:21
Más o menos estables 00:16:23
Pero que de alguna manera no van a comprometer 00:16:25
Ni la seguridad ni la integridad del servicio 00:16:27
Ayer en la mesa redonda sobre contenidos 00:16:29
Hubo algunos administradores 00:16:31
Que dijeron 00:16:33
Yo soy administrador y no me gusta que me hagan según que cosas 00:16:35
Porque me rompen el sistema 00:16:37
Pues la idea es esta 00:16:39
Que tener mecanismos 00:16:41
Para que los experimentadores experimenten 00:16:43
Y que el que tiene que mantener el sistema estable 00:16:45
Y sólido 00:16:47
Puede hacer su trabajo correctamente 00:16:49
Esa es la idea 00:16:51
A partir de aquí la gracia es que 00:16:53
Contra los webservices 00:16:55
Aparte del proyecto que estamos arrancando 00:16:57
Que sea un proyecto de software libre 00:16:59
Y abierto a comunidad 00:17:01
Y que ya comunicaremos donde ponemos el código 00:17:03
Porque está todo muy 00:17:05
Como en Moodle.org nos cambian continuamente el kernel 00:17:07
Vamos despacito 00:17:09
Pero cuando as cosas se congelen por debajo 00:17:11
Podemos empezar a construir cosas encima 00:17:13
Cuando se congela un lago 00:17:15
Puedes empezar a patinar 00:17:17
Con un gelo muy delgadito 00:17:19
La idea es que se podan hacer tanto estos proyectos 00:17:21
Como otros muchos proyectos 00:17:23
Proyectos de accesibilidad o proyectos de integración más sólida 00:17:25
Con otros sistemas 00:17:27
Esta es la idea 00:17:29
Y ahora Pig ya tenemos el sistema montado 00:17:31
Vamos a ver una serie de ejemplos 00:17:39
Con respecto a como los servicios web 00:17:41
Pueden aplicarse realmente 00:17:43
Como podemos extraer realmente información adecuada 00:17:45
Por ejemplo en aplicaciones de back-office 00:17:47
Esto es un cliente feo 00:17:49
Pero es un cliente que actualmente funciona contra los servicios web 00:17:51
Y vosotros diréis 00:17:53
Tiene que agregar usuarios 00:17:55
Tiene que sacar log, tiene que crear cursos 00:17:57
Como cualquier herramienta externa 00:17:59
Además a Moodle 00:18:01
Y sin ir contra la base de datos directamente 00:18:03
Pero por ejemplo 00:18:05
Pensad vosotros si quisierais hacer lo siguiente 00:18:07
Vosotros tenéis acceso al log de Moodle 00:18:09
Y creéis que cuando una persona lleva tres días sin entrar 00:18:11
Le mande automáticamente a Moodle 00:18:13
Un mensaje diciéndole ¿Qué te pasa? 00:18:15
Que podríamos hacerlo por otra parte 00:18:17
Podríamos peinarnos todo el log 00:18:19
Ver qué personas llevan sin entrar tres días 00:18:21
Y mandarles manualmente un mensaje 00:18:23
¿Qué nos aporta esto? 00:18:25
Nos aporta la capacidad de poder extraer todo eso 00:18:27
Desde unha aplicación completamente externa 00:18:29
Tratar esa información 00:18:31
Y después proporcionar 00:18:33
En este caso un servicio 00:18:35
Como sería el de seguimiento 00:18:37
De los usuarios 00:18:39
Por otro lado 00:18:41
¿Por qué no hacer esto en dispositivos móviles? 00:18:43
Actualmente existe un cliente móvil 00:18:45
Que permite, a través de servicios web 00:18:47
Esto está creciendo y se está cambiando 00:18:49
Conectarse a Moodle 00:18:51
Ir explorando las categorías 00:18:53
Ir explorando los diferentes cursos 00:18:55
Y dentro dos cursos acceder a cada recurso 00:18:57
Y reproducirlo adaptado al dispositivo móvil 00:18:59
Si existe una serie de servicios web 00:19:01
No nos tenemos que preocupar de como recuperamos la información 00:19:03
Nosotros nos tenemos que preocupar 00:19:05
De el rol que tenemos 00:19:07
Como nos conectamos 00:19:09
Nosotros tenemos accesos y de consumirlos 00:19:11
Desde el dispositivo móvil 00:19:13
Con lo cual nos olvidamos de toda la tecnología subyacente 00:19:15
Solamente nos centramos en funciones concretas 00:19:17
De lo que queremos hacer 00:19:19
Por otro lado 00:19:21
También podemos hacer 00:19:23
Prospección o visualización de la información 00:19:25
Nosotros tendemos muchísima información a través de Moodle 00:19:27
Por ejemplo 00:19:29
Las palabras más destacadas dentro de los posts 00:19:31
Cogemos todos los posts de Moodle 00:19:33
Extraemos las diferentes palabras 00:19:35
Y vemos en qué se está interesando más la gente 00:19:37
También podríamos ver 00:19:39
El número de aprobados 00:19:41
O cuánta gente entra en una determinada actividad 00:19:43
A partir de determinar si esa actividad es más popular 00:19:45
Menos popular 00:19:47
Si el curso se está conduciendo de una manera adecuada 00:19:49
Es decir, tomar decisiones de negocio 00:19:51
En función de determinada información 00:19:53
A través de técnicas como estas 00:19:55
De visualización 00:19:57
Se forman galaxias con diferentes palabras 00:19:59
Conectadas entre ellas 00:20:01
En distintas actividades del Moodle 00:20:03
También podríamos hacer algo como esto 00:20:05
Tener un análisis visual adaptativo 00:20:07
En el que nosotros determinamos qué características queremos 00:20:09
Y a través de información 00:20:11
Que podemos encontrar en el log de Moodle 00:20:13
Por ejemplo, ver cuándo se conecta más la gente 00:20:15
Esto, si os fijáis, es un círculo horario 00:20:17
Y estamos viendo que hay más manchas amarillas 00:20:19
En una zona determinada 00:20:21
Esas manchas amarillas serán cuándo se conecta más la gente 00:20:23
Aquí tendríamos, por ejemplo 00:20:25
Desde las ocho de la mañana 00:20:27
Hasta aproximadamente la una del mediodía 00:20:29
Hay bastantes conexiones 00:20:31
Y luego a las seis de la tarde se repetiría 00:20:33
Lo cual, si por ejemplo pensamos en hacer 00:20:35
Una actividad sincrona 00:20:37
Tendríamos que hacerla en una de esas horas 00:20:39
Que es cuando más gente va a ver 00:20:41
Este tipo de información se puede explotar en diferentes contextos 00:20:43
Y estos son algunos de los que podemos encontrarnos 00:20:45
También tenemos, debido a Jordi Pivillén 00:20:49
La integración de un conector 00:20:51
Para poder integrar herramientas externas 00:20:55
Dentro de Moodle, que era lo que comentaba antes Mark 00:20:57
Esos cafres que usan, por ejemplo 00:20:59
Google Docs, o que usamos Google Docs 00:21:01
Para impartir docencia 00:21:03
Pues integrar eso en el Moodle 00:21:05
A ver, la idea es que esto 00:21:09
Si os fijáis un poco, aquí pone 00:21:11
Simple LTIs 00:21:13
LTI es 00:21:15
Las siglas que significan 00:21:17
Learning Technologies for Interoperability 00:21:19
Que es un estándar que está desarrollando 00:21:21
El IMS 00:21:23
¿Cómo? 00:21:25
Ah, Learning Tools 00:21:27
Lo cambian cada día, o lo cambio yo 00:21:29
Bueno 00:21:31
La idea es que 00:21:33
El Learning Tools for Interoperability 00:21:35
No existe todavía, porque es un estándar 00:21:37
Que se está desarrollando 00:21:39
Lo que sí que se ha hecho es publicar 00:21:41
Una versión inicial de este estándar 00:21:43
Que es el Basic LTI 00:21:45
Que se incorpora dentro del estándar 00:21:47
Common Cartridge 1.1 00:21:49
El Common Cartridge original 00:21:51
El 1.0, está muy orientado 00:21:53
A coger contenidos 00:21:55
Y meterlos dentro de Moodle 00:21:57
Eso es estilo Scorn 00:21:59
Vemos que es hermoso 00:22:01
Mientras que 00:22:03
En el 1.1 00:22:05
Con la incorporación del LTI 00:22:07
El Basic LTI 00:22:09
La idea es que nosotros podemos tener 00:22:11
Una aplicación que no esté necesariamente 00:22:13
Diseñada para un Learning Management System 00:22:15
Como por ejemplo puede ser 00:22:17
Google Docs 00:22:19
Y a través de una pasarela 00:22:21
Que desarrolló Jordi Piguillem 00:22:23
En Google Application Engine 00:22:25
Lo que podemos hacer es que 00:22:27
Documentos concretos 00:22:29
De Google Docs 00:22:31
Entren dentro de Moodle 00:22:33
A través del cliente de LTI 00:22:35
Para poder desarrollar el cliente de Basic LTI 00:22:37
Es necesario 00:22:39
Disponer de la tecnología 00:22:41
De los web services que hay por detrás 00:22:43
Para poder implementar el Common Cartridge 1.1 00:22:45
Necesitamos esta parte 00:22:47
Es bastante interesante porque 00:22:49
Permitirá integrar muchísimas cosas 00:22:51
Tanto herramientas que están hechas fuera 00:22:53
Por ejemplo, alguien ha hecho una aplicación hecha en .net 00:22:55
Que no se puede integrar dentro de Moodle 00:22:57
Pues desta forma se podía integrar 00:22:59
Y además podíamos hacer que la herramienta 00:23:01
Supiera cosas sobre en que curso nos encontramos 00:23:03
Quien es el usuario que está utilizando ahora 00:23:05
Cual es el rol que tiene dentro de la actividad 00:23:07
Y además podíamos enviar 00:23:09
Cosas como información sobre logs 00:23:11
O información sobre notas 00:23:13
Con lo cual 00:23:15
Es muy útil 00:23:17
También podíamos hacer cosas relacionadas 00:23:19
Con temas de escalabilidad 00:23:21
Por ejemplo, si estamos en una gran instalación 00:23:23
Que el 50% 00:23:25
De los hits de la actividad 00:23:27
Se está dando siempre en el mismo módulo 00:23:29
Podríamos tener un Moodle 00:23:31
Que simplemente se encargue de generar foros 00:23:33
Y con un producer 00:23:35
De foro 00:23:37
Utilizar en el Moodle 00:23:39
De verdad, el Moodle del centro 00:23:41
Simplemente decir que los foros 00:23:43
Son foros que nos está sirviendo 00:23:45
Otra máquina 00:23:47
Y desta forma tendríamos dos máquinas en paralelo trabajando 00:23:49
Y repartiendo la carga 00:23:51
Es más barato 00:23:53
Tener dos máquinas 00:23:55
Que no poner una máquina el doble de potente 00:23:57
El coste es mucho más alto 00:23:59
¿Pasamos a siguiente? 00:24:03
Bueno, se trataba esto 00:24:11
De exportar los contenidos 00:24:13
De Moodle a través 00:24:15
Tanto de los web services como a través 00:24:17
Del productor de Basic LTI 00:24:19
Y este experimento cual es 00:24:21
A partir de aquí empezamos a trabajar 00:24:23
Actualmente hay 00:24:45
Dos CVS 00:24:47
Donde se encuentran las APIs 00:24:49
Una es en el core de Moodle 00:24:51
En el head de Moodle 2.0 00:24:53
Y otra es en un servidor que tenemos en mi despacho 00:24:55
Que se llama potato.lsi.upc.edu 00:24:57
Allí hay un tracker 00:25:01
Donde creo que tenemos accesible 00:25:03
La versión de desarrollo que estamos usando nosotros 00:25:05
Y ahí es donde vamos añadiendo funcionalidades 00:25:07
Lo que sí que es verdad 00:25:09
Es que nosotros queremos abrir 00:25:11
Bien pronto 00:25:13
¿Qué cosas queréis hacer? 00:25:15
Necesitamos estas funciones 00:25:17
Y digo que necesitamos 00:25:19
Que esto se empiece a activar 00:25:21
Y que tendría que pasar en el foro de web services 00:25:23
De Moodle 00:25:25
Y abriremos algún hilo por allí 00:25:27
Porque nos cuesta convencer a veces 00:25:29
A la gente de core de Moodle 00:25:31
Que se incorporan novas funcionalidades 00:25:33
Digamos 00:25:35
La gente que desarrolla el core de Moodle 00:25:37
Son conservadores 00:25:39
Uy, esto tal 00:25:41
Uy, seguridad 00:25:43
Esto no 00:25:45
Y por tanto es muy importante que la gente diga 00:25:47
Ey, que yo quiero hacer esto, que necesitamos esta función 00:25:49
¿Alguien? 00:25:53
¿Tiene algún comentario o pregunta? 00:25:55
O vamos a ver ya 00:25:57
El código 00:25:59
Y todos los que no sois programadores vais a empezar a poder desconectar 00:26:01
¿Joan? 00:26:03
Ah, o tomar un café también 00:26:05
Bueno 00:26:07
Es espotato.lsi.pc.edu 00:26:11
Barra projects 00:26:13
Barra Moodle web services 00:26:15
Y aquí tenéis el tracker 00:26:17
Con el git 00:26:19
Y con el código 00:26:21
Y esto es altamente experimental 00:26:23
Porque Jordi y Miguel Ángel 00:26:25
Ayer se tiraron cuatro horas 00:26:27
Majas 00:26:29
Para poderlo hacer funcionar 00:26:31
Porque hace una semana Peter entró 00:26:33
En velocidad y dejó de funcionar todo 00:26:35
Y bueno 00:26:37
La cosa es bastante 00:26:39
Está bastante verde 00:26:43
Pero precisamente por esto 00:26:45
Porque el core no se está quieto 00:26:47
Pero está cogiendo velocidad 00:26:49
¿Jordi? 00:26:51
Teo 00:26:53
Pues vale, tenéis todos 00:26:57
Un portátil, ¿no? 00:26:59
Pues si os conectáis a esta url 00:27:01
Veréis al mío 00:27:05
Y os deberíais bajar el zip 00:27:07
Que hay aquí, que se llama 00:27:09
Mood09ws 00:27:11
Vale, espérate 00:27:15
Podría poner el zoom, pero bueno 00:27:17
Es http://192.168.11.169.8888 00:27:19
¿No lo coge? 00:27:31
A lo mejor me ha cambiado la IP 00:27:35
A ver 00:27:37
¿Sí? 00:27:39
¿Cómo? 00:27:45
¿Y por cable? 00:27:47
¿Por cable no llega? 00:27:49
¿Hay cable? 00:27:51
No sé, a lo mejor si lo enchufo 00:27:55
Ayer funcionaba 00:27:57
A ver 00:28:01
Dime 00:28:05
Lo he mirado, lo he mirado, espera 00:28:07
A ver 00:28:09
Toma, toma, toma 00:28:15
¿Me das? 00:28:17
Voy a buscar a vos 00:28:23
A ver 00:28:25
Buscar a alguien 00:28:31
No sé 00:28:41
Dime, busca a alguien 00:28:45
Por wales ayer iba 00:28:51
¿Tienes IP? 00:28:53
¿Tengo? 00:28:55
No tengo IP yo ahora 00:29:07
A ver 00:29:09
Necesito saber que es esta máquina 00:29:23
La IP es la 11.169 00:29:25
Bueno, tenéis todos 00:29:27
Tenéis todos el zip bajado 00:29:29
Vale, lo tenéis en el escritorio 00:29:31
Bueno, la intención es que abráis un navegador 00:29:33
Vale, y comprobéis que funciona 00:29:35
Y ponéis localhost 00:29:37
Que es el Apache 00:29:39
Entonces entráis en el navegador 00:29:41
Ponéis localhost 00:29:43
Y os tiene que salir 00:29:45
Eliteworks 00:29:47
Vale 00:29:49
Vale, pues si todos tenéis 00:30:05
El localhost funcionando con el Apache 00:30:07
Lo que tenéis que hacer es entrar en modo comando 00:30:09
Con un terminal 00:30:11
Y os tenéis que ir a la raíz 00:30:15
Os tenéis que ir a la raíz 00:30:17
Del directorio de Ubuntu 00:30:23
Y en el barra bar 00:30:29
Barra www 00:30:31
Poder hacer un directorio 00:30:33
En el sitio raíz de donde se consiguen los recursos 00:30:47
Vale 00:30:49
Si, pero como no tenéis privilegios 00:30:53
Primero lo que tenéis que hacer es un sudo su 00:30:55
Y el password es cmadrid 00:30:57
Sudo su 00:30:59
Y el password es cmadrid 00:31:01
Lo que habéis puesto a la entrada de password 00:31:03
Si? 00:31:05
Podéis? 00:31:07
Estáis todos en el barra bar barra www 00:31:09
Habéis hecho el sudo su 00:31:13
Podéis? 00:31:17
Vale, y aquí hacéis un directorio 00:31:19
Con el comando mkdir 00:31:21
Y dentro de ese directorio 00:31:23
Podéis copiar todos los archivos 00:31:25
Cmadrid 00:31:29
Hay alguien que esté perdido en el 00:31:41
Si, ósea y los archivos 00:31:43
Que habéis descomprimido en el escritorio 00:31:45
Los tenéis que copiar dentro de ese directorio 00:31:47
Que habéis creado en el www 00:31:49
El comando es cp 00:31:53
La fuente del fichero 00:31:55
La fuente del directorio 00:31:57
Y el destino del directorio 00:31:59
Ósea un ejemplo sería cp 00:32:01
Barra home 00:32:03
Madrid 00:32:05
Escritorio 00:32:07
Donde indicáis los archivos 00:32:09
Y la fuente 00:32:11
Y el destino perdón 00:32:13
Barra bar barra www 00:32:15
El directorio que habéis creado 00:32:17
Podéis hacerlo así? 00:32:19
Sería home 00:32:21
Barra Madrid 00:32:23
Barra escritorio 00:32:25
Escritorio en castellano 00:32:27
Y ahora entonces pondríais el directorio 00:32:29
Donde lo habéis descomprimido 00:32:31
Que es model webservice 00:32:33
Barra 00:32:35
Y le ponéis 00:32:37
Una barra y le pones un asterisco 00:32:39
Se copian todos los archivos que hay en ese directorio 00:32:41
Y luego 00:32:43
El destino que es barra bar 00:32:45
Barra bar 00:32:47
Barra www 00:32:49
Barra el directorio que habéis creado 00:32:51
Puede ser prueba, prueba webservice 00:32:53
Lo que hayáis puesto 00:32:55
Pon prueba 00:32:57
Pon prueba webservice y ya está 00:32:59
Al final del este 00:33:01
Pon después del barra bar 00:33:05
Pon prueba webservice 00:33:07
Barra 00:33:12
Te falta una barra más 00:33:14
Para decir que va dentro 00:33:16
Vale? 00:33:18
Es más o menos el ejemplo este 00:33:23
Si habéis descomprimido el zip en el escritorio 00:33:27
Debería ser así 00:33:29
Alguien no ha podido? 00:33:31
Ou alguien ha podido 00:33:33
Háis podido? 00:33:35
Vale, entón dentro deste directorio 00:33:37
Vosotros estáis tendo todos os ficheros 00:33:41
Que agora modificaremos 00:33:43
E entón en el localhost 00:33:47
Lo único que tenéis que poner é 00:33:49
localhost barra 00:33:51
O nome do directorio que habéis creado 00:33:53
No navegador de Firefox 00:33:55
Podéis? 00:33:59
Vale isto? 00:34:01
Este? 00:34:03
Tenéis todos, no? 00:34:07
Todo mundo lo teña copiado, ya? 00:34:09
Vale, pues lo próximo 00:34:11
Sería que con el Firefox 00:34:13
O navegador que tengáis 00:34:15
Accedáis a localhost 00:34:17
Barra 00:34:19
Olvidaos de los ochos 00:34:21
Y la carpeta que la habéis llamado 00:34:25
mod09ws 00:34:27
O prueba 00:34:33
O como la habéis llamado 00:34:35
Tendría que salir suces 00:34:39
Lo tenéis, no? 00:34:45
Vale, pues esto es una especie 00:34:47
De mini cliente 00:34:49
Que aprovecha los web services 00:34:51
Para 00:34:53
Crear unos cuantos usuarios 00:34:55
Y unos cuantos cursos 00:34:57
Vale, es muy sencillo, lo hice viniendo en el tren 00:34:59
Y es muy simple 00:35:01
Como veis, solo pone suces 00:35:03
Y no hay ningún formulario 00:35:05
Ningún botón, ni nada 00:35:07
Vale, si 00:35:09
Examináis la carpeta 00:35:11
Que habéis copiado dentro de 00:35:13
www 00:35:15
Veréis que hay 00:35:17
Un archivo que se llama index.php 00:35:19
Hay un client.php 00:35:21
Hay un par de archivos 00:35:27
De valores separados por comas 00:35:29
No podrán editar los archivos 00:35:33
Si no hacen el chmod 00:35:35
Pongo el chmod 00:35:37
Vale, hazlo 00:35:39
¿Dónde tenéis el más? 00:35:47
¿El más o su más? 00:35:49
Un 777 00:35:51
¿Dónde tenéis el más? 00:35:53
¿Dónde tenéis el más? 00:35:55
¿Dónde tenéis el más? 00:35:57
Bueno, técnicamente, para que no tengáis problemas 00:36:15
De escritura y luego guardar los ficheros 00:36:17
En el directorio donde habéis descomprimido 00:36:19
Todos los... bueno 00:36:21
En el directorio del www 00:36:23
Donde habéis descomprimido los ficheros 00:36:25
Y los tenéis todos los .php 00:36:27
Deberíais ejecutar este comando 00:36:29
Da permisos de escritura, lectura a todos los usuarios 00:36:31
Así podréis guardar, salvar y... 00:36:33
Así a partir de ahora 00:36:39
No tendréis ningún problema 00:36:41
Ni para guardar, ni para ejecutar los scripts 00:36:43
¿Podéis? 00:36:45
¿Sabéis? 00:36:47
Ahora os tiene que salir todo rwx 00:36:49
En todos os lados 00:36:51
¿Si? 00:36:55
¿Si? 00:36:57
Bueno 00:37:01
Ahora ya podréis utilizar un editor de texto normal 00:37:03
Para editar el... 00:37:05
El contenido de los .php 00:37:07
¿Estáis podendo hacerlo? 00:37:13
Vale 00:37:15
Bueno 00:37:17
Ahora si queréis podéis editar 00:37:23
El índex .php 00:37:25
Que es donde... 00:37:27
Donde estará el ejemplo que vamos a ejecutar 00:37:29
¿Estáis? 00:37:41
¿Podéis? 00:37:43
Vale 00:37:45
Bueno la idea es que 00:37:47
Como todos vais a acceder contra el mismo 00:37:49
Moodle que está aquí 00:37:51
Que es el Moodle de servidor que tiene los webservice 00:37:53
La idea es que al principio de todo 00:37:55
Tenéis una categoría 00:37:57
Si subís al principio del fichero 00:37:59
Tenéis una categoría 00:38:01
Una variable que es categoría 00:38:03
Que es un string un poco raro 00:38:05
Si del índex .php 00:38:07
Vale y tenéis una 00:38:09
Variable que es categoría 00:38:11
La idea es que esa xxx 00:38:13
Es lo que se concatenará a todos los nombres de usuario 00:38:15
De perfil 00:38:17
De curso 00:38:19
Y como vais a acceder a todos al mismo Moodle 00:38:21
Y Moodle sabéis que tiene las restricciones 00:38:23
De emails 00:38:25
De nombres de curso 00:38:27
De shortnames 00:38:29
Para que no os repitáis 00:38:31
Yo lo que os recomiendo es que por filas 00:38:33
Esta sea la A, la B, la C 00:38:35
La D 00:38:37
Y a cada uno de vosotros 00:38:39
Ponéis la categoría como A 00:38:41
Y un número 00:38:43
Más que nada para que no coincidáis 00:38:45
Donde pone categoría xxx 00:38:47
Cada uno ponga 00:38:51
A, B, C 00:38:53
D, E, F 00:38:55
G, G 00:38:57
Y luego cada uno de vosotros 00:38:59
Aparte ponéis un número aleatorio 00:39:01
Después de la G 00:39:03
Yo que sé 00:39:05
Pongamos que 00:39:07
Yo pongo la W 00:39:09
Y soy la fila con la posición esta 00:39:11
Así ya sé que todos los nombres 00:39:13
Que tenga 00:39:15
Así todos podréis ver 00:39:27
Luego vuestros cursos 00:39:29
Y vuestras categorías creadas 00:39:31
Más que nada es que si no 00:39:33
Se os repetirán 00:39:35
Y os dará errores 00:39:37
Aquí como podéis ver 00:39:43
El servidor que definimos es el de Moodle 00:39:45
De este ordenador al que todos vais a acceder directamente 00:39:47
Y sobre los que vais a cargar 00:39:49
Los usuarios 00:39:51
Estáis... 00:39:53
¿Hay alguien que se haya perdido en estos pasos? 00:40:07
¿O que no haya llegado hasta aquí? 00:40:09
¿El qué? 00:40:15
Ah, el path completo del servidor 00:40:19
Espera 00:40:21
¿Coges tú el de este o que? 00:40:23
¿Si no? 00:40:25
Toma 00:40:27
¿Lo habéis puesto también? 00:40:31
El... 00:40:33
El servidor 00:40:35
Debéis copiar esto tal cual 00:40:37
Que es la dirección del Moodle que hay en ese portátil 00:40:39
Pues... 00:40:41
Lo primero que hay debajo de esto en el documento 00:40:43
Se incluye un par de librerías 00:40:45
¿Vale? 00:40:47
Una para... 00:40:49
Es un pequeño cliente 00:40:51
Vamos a utilizar en este caso 00:40:53
El conector REST 00:40:55
Para invocar a los servicios 00:40:57
Es un pequeño cliente que hice 00:40:59
Si lo queréis mirar 00:41:01
Es muy sencillo 00:41:03
Y debajo hay otra librería 00:41:05
Que se encarga de tratar 00:41:07
Archivos CSV 00:41:09
Que utilizaremos para 00:41:11
Abrir los archivos de 00:41:15
Usuarios y los archivos de cursos 00:41:17
Para leerlos y cargarlos 00:41:19
En el servidor 00:41:21
¿De acuerdo? 00:41:23
Debajo del todo 00:41:25
¿Dime? 00:41:27
¿Alguien decía algo? 00:41:29
Aquí debajo 00:41:31
Está la URL 00:41:33
Del servidor 00:41:35
En este caso 00:41:37
Los conectores están 00:41:39
En la carpeta de webservice 00:41:41
Dentro de Moodle 00:41:43
Hay un conector y un nombre del servidor 00:41:45
En este caso es el servidor REST 00:41:47
Y es una implementación sencilla 00:41:49
Que lleva Moodle para 00:41:51
Hacer pruebas del servicio 00:41:53
Aquí no tendrías que tocar nada 00:41:55
Lo que sí se tendría que 00:41:57
Está comentado 00:41:59
En vuestro código 00:42:01
Que sería crear la clase esta 00:42:03
De webservice REST es client 00:42:05
Para inicializar 00:42:07
El cliente 00:42:09
Que utilizaremos para invocar los servicios 00:42:11
O sea, añadiendo esta línea 00:42:13
Podríamos seguir para adelante 00:42:15
¿Lo tenemos ya? 00:42:17
¿Sí? 00:42:19
¿Alguien está 00:42:21
Atascado en algún lado? 00:42:23
¿No? 00:42:25
Vale, pues si os fijáis 00:42:27
Lo que deberíamos hacer es 00:42:35
Vosotros 00:42:37
Creo que tenéis comentado 00:42:39
Este trozo de aquí 00:42:41
¿Vale? 00:42:43
Donde se construyen los parámetros 00:42:45
Para invocar 00:42:47
Al servicio web 00:42:49
En este caso 00:42:51
La primera línea de ahí 00:42:53
Que pone content 00:42:55
Lo que hace es abrir el archivo separado por comas 00:42:57
Que tenéis en vuestro 00:42:59
En vuestro localhost 00:43:01
Y devolverlos 00:43:03
Lo que hay 00:43:05
Con el bucle lo que hacemos es 00:43:07
Coger los valores separados por comas 00:43:09
Y irlos metiéndolos dentro de una array 00:43:11
Para invocar el servicio 00:43:13
O sea, sería cuestión de copiar 00:43:15
Estas líneas 00:43:17
Para que 00:43:19
Podamos invocar al servicio 00:43:21
¿Lo tenéis todos esto copiado ya? 00:43:23
Si, supongo que si 00:43:25
¿Qué habéis hecho? 00:43:27
¿Qué habéis copiado? 00:43:29
¿Dime? 00:43:31
¿Por qué? 00:43:33
¿Esto qué es? 00:43:35
Esto es una array de array de array 00:43:37
¿Vale? Es un poco así como 00:43:39
Complicado pero bueno 00:43:41
Todas las funciones de localhost 00:43:43
Funcionan de esta manera 00:43:45
Primero 00:43:47
Le pasas 00:43:49
Una primera posición del array que es el objeto 00:43:51
Que queremos crear 00:43:53
Entonces tenemos 00:43:55
N posiciones donde hay 00:43:57
X campos que son los parámetros 00:43:59
Que va a recibir 00:44:01
La función 00:44:03
Entonces lo que hace la capa externa es iterar 00:44:05
En cada posición 00:44:07
De este array 00:44:09
Para obtener los parámetros 00:44:11
Y llamar X veces la función de crear usuario 00:44:13
¿Vale? En este caso 00:44:15
La API 00:44:17
Pide obligatoriamente estos campos 00:44:21
Para crear un usuario 00:44:23
Este es opcional 00:44:25
Para que veáis, si borráis uno destos no funcionaría 00:44:27
No podríais crear el usuario 00:44:29
Este es opcional, lo he puesto para que 00:44:31
Se viera normalmente 00:44:33
Todas las facultades usan el campo 00:44:35
Diginumber para identificar de alguna manera 00:44:37
Los usuarios internamente con el DNI 00:44:39
O con un número 00:44:41
De gestión interna 00:44:43
¿Vale? Lo próximo 00:44:45
Sería, o mejor ya muchos ya lo habéis puesto 00:44:47
Es hacerle llamada 00:44:49
Al servicio web 00:44:51
¿Lo habéis copiado? ¿Todos? 00:44:53
¿Si? Vale guay 00:44:55
En este caso lo que hace es 00:44:57
El cliente invoca 00:44:59
La operación 00:45:01
Moodle user create users con los parámetros que hemos construido 00:45:03
¿Por qué esto? 00:45:05
A ver, Moodle 00:45:07
Estamos invocando a una función de Moodle 00:45:09
User, estamos invocando a una operación 00:45:11
Que está dentro del componente de gestión 00:45:13
De usuarios 00:45:15
Y creo que Alberto, Miguel Ángelos 00:45:17
Enseñó el diagrama de componentes 00:45:19
Con el core, el external 00:45:21
Pues estamos invocando a una operación que está 00:45:23
En la capa del medio 00:45:25
De usuarios 00:45:27
Y invocamos a la operación de crear usuarios 00:45:29
En este caso 00:45:31
Si ya lo tenéis todo expuesto 00:45:33
Y vais 00:45:35
Al Firefox 00:45:39
Igual o que tengáis 00:45:43
Y en esta pantalla 00:45:45
Actualizáis, le dais al F5 00:45:47
En... 00:45:49
Debería daros suces igualmente 00:45:51
¿Dime? 00:45:53
No lo habías copiado, vale 00:45:59
Vale, ahora os podéis conectar 00:46:03
Al Moodle 00:46:05
Y con este usuario y password sois administradores 00:46:07
Y podréis, con Moodle y Moodle Pass 00:46:09
Vale 00:46:11
Y podréis ir a la pantalla de administración 00:46:13
Y ver que realmente se os han creado 00:46:15
Estes usuarios 00:46:17
Bueno, ahora 00:46:19
Cada uno de vosotros deberíais de poder acceder 00:46:21
A la... 00:46:23
A esta misma página que está accediendo 00:46:25
Jordi 00:46:27
Y entonces podéis 00:46:29
Loguearos con el mismo 00:46:31
Password de usuario 00:46:33
Que tenéis dentro de index.php 00:46:35
Vale, entonces 00:46:37
Cuando vayáis a la lista de usuarios 00:46:39
Authentic 00:46:41
Accounts, Worklist, exacto 00:46:43
Aquí podréis 00:46:45
Ver los usuarios 00:46:47
O sea, si filtráis ahora en el filtro de arriba 00:46:49
Aquí, show of banks 00:46:51
Podéis, por first name 00:46:55
Le podéis poner la categoría que habéis puesto vosotros 00:46:57
Vamos 00:46:59
El descriptor que habíais puesto 00:47:01
Dentro de vuestro index.php 00:47:03
Lo podéis utilizar para buscar los usuarios 00:47:05
Que vosotros habéis creado 00:47:07
Entonces técnicamente 00:47:09
Bueno, entonces salen un montón 00:47:13
Ah, vale, vale 00:47:17
Es first name 00:47:23
Sí, búscalo en first name y ya está 00:47:25
Aquí no 00:47:27
Vale, o sea, cada uno de vosotros 00:47:29
Buscáis vuestra constante 00:47:31
Que habéis definido en categoría 00:47:33
Y lo ponéis en first name 00:47:35
No en surname, tío 00:47:37
Lo has puesto en first name, tío 00:47:39
No en surname 00:47:41
Aquí 00:47:43
Ahí 00:47:45
¿Os salen los vuestros? 00:47:47
¿Hay alguien que no les salga, que no los encuentre? 00:47:49
¿Sí? ¿Están o no? 00:47:53
Tienes que borrar el filtro de arriba 00:47:55
No, remove selected 00:47:57
Vale, os tendrían que salir nueve usuarios 00:48:01
Más o menos así 00:48:05
¿Hay alguien que haya tenido problemas? 00:48:09
Espera, toma 00:48:11
¿Vas para allá? 00:48:13
¿Lo veis todos? 00:48:15
¿Sí? 00:48:17
Viene a ser 00:48:23
Lo mismo que para crear los usuarios 00:48:25
Lo que los parámetros son distintos 00:48:27
En este caso 00:48:29
Se haría un array de cursos 00:48:31
Con los parámetros de turno 00:48:33
Y se invocaría a la función call model 00:48:35
Curse, createCurses 00:48:37
Es muy parecido 00:48:39
Vamos allá y enseñaros una cosa antes de plegar 00:48:41
Que es como funciona esto por dentro 00:48:43
¿Qué pinta tiene un external? 00:48:49
Este no es 00:48:53
Vale, en la carpeta 00:49:11
Dentro de model 00:49:13
En la carpeta users 00:49:15
Se ha añadido 00:49:17
Un archivo nuevo que se llama 00:49:19
externallib.php 00:49:21
Lo mismo se ha hecho en la carpeta de cursos 00:49:23
En la carpeta 00:49:25
Del lesson 00:49:27
Del foro 00:49:29
De los componentes que nos parecian interesantes 00:49:31
A exportar servicios 00:49:33
De ellos 00:49:35
Y a poder dar acceso desde fuera 00:49:37
¿Cómo funciona esto? 00:49:39
Se han creado las funciones 00:49:41
En este caso la createUser que es la que hemos estado utilizando 00:49:43
Que 00:49:45
Trata los parámetros que recibe 00:49:47
Y acaba invocando 00:49:49
Las operaciones 00:49:51
De core 00:49:53
¿Vale? 00:49:59
Que toca para crear el usuario 00:50:01
Pero como 00:50:03
Se gestiona lo de los parámetros 00:50:05
Se han añadido funciones 00:50:07
Para cada uno de los servicios 00:50:11
Se ha creado una función que es 00:50:13
Nombre de la función 00:50:15
CreateUser 00:50:17
Parámetros 00:50:19
Igualmente returns 00:50:21
Donde se expone de forma estructurada 00:50:23
Como son los parámetros 00:50:25
Cuales son los parámetros que admite ese servicio 00:50:27
En este caso tenemos que 00:50:29
Para crear un usuario 00:50:31
Necesitamos 00:50:33
Estos cinco parámetros de forma 00:50:35
Obligatoria 00:50:37
El username, el password, el firstname, el lastname y el email 00:50:39
¿Vale? Estos de aquí 00:50:41
Los que están marcados como false 00:50:43
En esta zona son opcionales 00:50:45
Cada institución puede 00:50:47
Decidir utilizarlos o no utilizarlos 00:50:49
O por ejemplo directamente 00:50:51
Para configurar el tipo de autenticación 00:50:53
Para cambiarles el lang 00:50:55
Lo que sea 00:50:57
Entonces todos los externos 00:50:59
Funcionan de esta manera para definir los parámetros 00:51:01
Y de igual manera 00:51:03
Para definir 00:51:05
Como se devuelven 00:51:07
Los resultados 00:51:09
Cada invocación al servicio puede devolver 00:51:11
O lo que pone aquí 00:51:13
En este caso 00:51:15
Un array de arrays con ids 00:51:17
Los ids que se ha creado al usuario 00:51:19
O con mensajes 00:51:21
De excepción 00:51:23
Indicando si ha habido algún tipo de error 00:51:25
El username ya existía 00:51:29
Si faltaba otro en la base de datos 00:51:31
Te lo indica 00:51:33
Si faltaba un parámetro obligatorio te lo indica 00:51:35
Si lo que es probar podéis hacer un printr 00:51:37
Del response 00:51:39
Y lo veréis en pantalla 00:51:41
En el Firefox 00:51:43
Directamente si le dais al control u para ver el código html 00:51:45
Lo veréis printado ahí 00:51:47
En ese caso 00:51:49
Hago un ejemplillo 00:51:51
Y ya lo dejaríamos aquí 00:51:53
En este caso he ejecutado la misma operación de antes 00:51:55
El primer curso que ha pedido 00:51:57
Crear ya existía 00:51:59
Con lo que me salta 00:52:01
El xml 00:52:03
Contiene una excepción 00:52:05
Que contiene un mensaje 00:52:07
Que es 00:52:09
Que el shortname ya está usado 00:52:11
Con lo que se puede 00:52:13
Tratar 00:52:15
Para recuperar el estado 00:52:17
De excepción 00:52:19
O mostrar un mensaje por pantalla 00:52:21
Para poder dar un poco 00:52:23
De que es lo que ha pasado 00:52:25
Dejame hacer la despedida 00:52:27
Dime 00:52:29
Pues ya por aquí acabamos 00:52:31
Bueno solamente deciros 00:52:33
Que es un trabajo que estamos todavía desarrollando 00:52:35
Que habrá más cambios 00:52:37
Pero que os hagáis una idea 00:52:39
De por lo menos cual es la arquitectura 00:52:41
Que es lo que se está planteando 00:52:43
Y sobre todo a donde nos va a permitir llegar 00:52:45
Que es lo más importante 00:52:47
Nos permite crecer de una manera 00:52:49
Nos permite desvincularnos completamente 00:52:51
De la versión de Moodle 00:52:53
Que se han comprometido a mantenerlas 00:52:55
Podremos tener versiones perdurables 00:52:57
En el tiempo de aplicaciones externas que utilicen los servicios de Moodle 00:52:59
Esto es todo y gracias por haber venido 00:53:01
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Autor/es:
Marc Alier, Jordi Piguillem y Miguel Angel Conde
Subido por:
EducaMadrid
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
4249
Fecha:
24 de febrero de 2010 - 10:51
Visibilidad:
Público
Enlace Relacionado:
Comité Organizador Moodle Moot 09
Descripción ampliada:
Taller práctico sobre integración de Moodle con istemas externos con la capa de webservices deMoodle 2.0 y Moodle 1.9.
Duración:
53′ 16″
Relación de aspecto:
1.26:1
Resolución:
448x356 píxeles
Tamaño:
396.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid