DWES. Unidad 8. Repaso OAuth 2.0. Google Tasks API REST. Diseño solución tarea Repartos. Parte 1

Listo. Venga, pues empezamos con la tutoría de esta semana. 00:00:00

Una de las últimas ya que tenemos pendientes en cuanto a seguir avanzando en contenido. 00:00:08

Todavía nos quedan algunas más que intentaremos, no sé, resolver exámenes del año pasado 00:00:18

o atender a dudas, si queréis, ya petición un poco, lo que podáis incluso enviar al foro, si queréis que se trate algún tema, de cara ya a la preparación de la prueba, las dos pruebas que vamos a tener en junio. 00:00:23

Ordinaria, que la pruebe, pues estupendo, y si no, pues hay otra oportunidad en la convocatoria extraordinaria. 00:00:42

Vale, pues hoy voy a hacer un poquito de breve repaso de lo último que cubrimos en la tutoría pasada, 00:00:51

que fue una tutoría, bueno, pues también bastante tensa porque se incorporó bastante código de ejercicios 00:01:04

que utilizaban APIs REST 00:01:12

es otro tipo de 00:01:14

servicios web más 00:01:16

importantes y cabe que los servicios 00:01:17

SOAP porque 00:01:20

su uso es bastante más 00:01:21

más frecuente, más popular 00:01:24

con lo cual es un 00:01:27

un ámbito de 00:01:30

de 00:01:32

trabajo 00:01:34

que os animo a que 00:01:35

trabajéis 00:01:38

y lo preparéis bien 00:01:39

lo digo porque si trabajáis en la parte backend 00:01:44

mucho de la interfaz que vais a tener con el frontend va a ser 00:01:47

vía servicios REST y muchas veces 00:01:51

es obviamente responsabilidad del programador 00:01:54

del backend el programar esos APIs 00:01:57

para que desde el frontend se pueda hacer uso 00:02:00

de ellos y se pueda solicitar toda la información que luego 00:02:03

directamente desde Javascript 00:02:05

o normalmente utilizando frameworks de cliente, pues esa información se va convirtiendo en contenido 00:02:09

dentro de las páginas que hacen de interfaz con la aplicación del usuario. 00:02:16

Entonces, es un área que debéis de dominar o debéis de alguna manera al menos de conocer 00:02:23

de cara a que si ya vais a hacer prácticas o estáis aplicando por algún puesto, 00:02:28

Que tengáis más o menos unas ideas claras que podáis un poco demostrar durante una entrevista técnica o este tipo de interacciones que podéis tener a la hora de participar en un proceso de selección. 00:02:39

Vale, pues como parte de esta estrategia, de esta tecnología de API REST y también quizá como ejercicio integrador de todo lo que hemos hecho durante el curso, tenemos esta última tarea. 00:02:55

Es una tarea en la que se os da mucho código de partida, pero luego la tarea os pide que avancéis en esa funcionalidad, la tarea 8. 00:03:16

Es una tarea compleja porque ya aparte de que hay mucho código que se os da de base y que, bueno, es código que utiliza ya muchas cosas, como digo, porque hace un poco de tarea integradora. 00:03:26

Luego el código que se pide también es un código, bueno, que requiere también tiempo y requiere trabajarlo con calma. 00:03:39

Es una tarea que os puede llevar mucho tiempo, entonces tenéis que decidir un poco hasta dónde queréis llegar profundizando en ella. 00:03:51

Podéis ver la solución cuando se publique, incluso puedo adelantar la solución si es que tenéis interés en verla antes de que cumpla el plazo para de alguna manera tener esa posibilidad de hacer ese ejercicio de inspección de código. 00:03:59

pero yo recomiendo 00:04:16

que a lo mejor no 00:04:18

dediquéis 00:04:20

demasiado tiempo en poner esta aplicación 00:04:22

a punto 00:04:24

y dejéis quizá, o os quedéis 00:04:25

sin tiempo para un repaso más general 00:04:28

de, como digo 00:04:30

si trabajáis en esta aplicación vais a 00:04:32

estar practicando, cosas de 00:04:34

que prácticamente tenéis que 00:04:36

llevar a cabo, pero bueno, dejar 00:04:38

unos días pues para ver las otras 00:04:40

tareas que se han hecho en otras unidades, para 00:04:42

de los códigos que se han ido trabajando 00:04:44

para hacer un repaso un poquito 00:04:47

más completo, porque esta tarea os puede 00:04:48

consumir, yo creo 00:04:50

muchísimo del tiempo que os queda 00:04:52

de cara 00:04:54

o hasta el final del curso 00:04:55

tampoco quedan muchas semanas 00:04:58

menos de cuatro semanas para 00:05:00

la primera prueba 00:05:02

pero digo, es un código 00:05:03

muy interesante, y entonces esta tutoría 00:05:06

y quizá la tutoría 00:05:08

de la semana que viene, os voy 00:05:10

dar mucha información sobre esta sobre esta aplicación a nivel de código para que uno 00:05:12

entendáis el código bien 2 si tenéis dudas y hay algo que no entendéis podéis preguntarlo 00:05:19

sobre la explicación de la tarea y 3 si os animáis si la hacéis que si vais un poquito 00:05:24

colgados de tiempo os lo recomiendo del todo tengáis una más fácil de alguna manera aproximación 00:05:31

a resolverlo, porque voy a trabajar la versión final, la que os voy a presentar y voy a explicar 00:05:39

la versión de la solución. Entonces, esa es un poco la idea. Voy a empezar haciendo ese breve repaso 00:05:47

de lo que es out y viene un poco a establecer un método de autenticación para que una aplicación 00:05:58

pueda acceder a datos que son privados de un usuario de nuevo imaginaros una persona que 00:06:13

tiene sus fotos en un servicio de cloud obviamente el acceso a esas fotos es autenticado porque son 00:06:20

de ese usuario y cualquiera o él cuando quiere hacer cualquier operación de gestión sobre esas 00:06:32

fotos pues se le pide que se autentique qué ocurre cuando una aplicación para ofrecer un 00:06:39

servicio a ese mismo usuario viene bien por la operativa del servicio de esa aplicación tener 00:06:46

acceso a los datos privados que su usuario puede tener una red social en un repositorio suyo privado 00:06:55

en millones de aspectos en los que nosotros estamos dados de alta y con nuestra contraseña 00:07:03

podemos acceder en temas de banca temas de registros personales etcétera cómo se soluciona 00:07:08

ese problema no hay aplicaciones muy útiles muy interesantes que por como digo por la operativa 00:07:15

y por facilitar el acceso a esa información pues el usuario ve con buenos ojos que pueda 00:07:22

poder o que tenga posibilidad de acceder a esa información privada pero claro aquí hay 00:07:30

tres agentes principales, el usuario final, esa aplicación y el proveedor o el garante 00:07:37

de que esos datos no sean accedidos por otra persona o por otro mecanismo que no sea el 00:07:50

del usuario final. En este caso, como digo, Picasa o Google Fotos o Facebook o tu banco 00:07:57

o obviamente esa aplicación esa organización no puede o no debería permitir que cualquier 00:08:04

aplicación simplemente le solicitará los datos de un usuario y dárselo sin más o sea que hay 00:08:14

como 33 agentes ahí funcionando entonces para solucionar esto se diseña este protocolo esta 00:08:20

interacción a tres bandas que se llama oce en la versión 2.0 vale una que se llama open con 00:08:32

ex hay tenido varios nombres y de ahí ha salido off 1.0 y ahora la que un poco más revisado un 00:08:42

poco más segura supongo la verdad más seguridad es la versión de off 2.0 entonces vamos a ver 00:08:50

cómo funciona en un ejemplo muy alto nivel, luego vamos a ver lo específico con la aplicación que 00:08:56

os mostré y que espero que ya esta segunda vuelta ya tenga más sentido, cómo funciona la operativa 00:09:04

y luego vamos a verlo en un tercer escenario que es el código que utilizamos dentro de la tarea 00:09:12

para hacer esta operativa 00:09:20

vale, vamos a ver un poquito 00:09:22

vamos a explicar un poquito la tarea 00:09:24

contextualmente, un poquito para que entendáis 00:09:25

por qué es necesario utilizar 00:09:28

y luego vamos a ver el código 00:09:30

que hace que esto 00:09:31

funcione y que una aplicación 00:09:34

al principio la que vosotros vais a programar 00:09:35

va a poder acceder 00:09:38

a tareas 00:09:40

que es una aplicación 00:09:43

de Google 00:09:45

obviamente cada uno tiene la suya, si no quiere que nadie 00:09:45

acceda a ellas, es un 00:09:48

servicio de este tipo 00:09:50

en el que cada usuario puede 00:09:52

establecer su agenda 00:09:54

de tareas, pero 00:09:56

es una información privada 00:09:57

¿cómo puede ser que una aplicación 00:10:00

pueda acceder a esa 00:10:02

información privada de un usuario, siempre que le dé 00:10:04

permisos? 00:10:06

Vale, entonces vamos a ver con esos tres 00:10:08

escalones y espero que con esas 00:10:10

tres perspectivas sí que 00:10:12

más o menos entendamos 00:10:14

cómo 00:10:16

funciona esto y cómo se hace 00:10:17

y cómo lo podemos poner en marcha. 00:10:19

Vale, pues este es el ejemplo que 00:10:22

os planteaba la semana pasada. 00:10:23

Es una aplicación 00:10:26

que lo que hace es 00:10:27

coger fotos e imprimir 00:10:29

álbumes que te los envía a casa. 00:10:32

Se llama Printfast. 00:10:35

Y esta es la web 00:10:36

de esa aplicación. 00:10:37

Acordaros que tenemos las tres patas. 00:10:39

El usuario, 00:10:40

la aplicación, 00:10:42

que da un servicio a ese usuario 00:10:44

y el repositorio de la información privada de su usuario al que esta aplicación tiene que acceder para llevar a cabo el servicio. 00:10:46

Entonces, esta aplicación que imprime álbumes le viene muy bien poder acceder directamente a los repositorios de fotos del usuario. 00:10:55

En vez de pedirle al usuario que esté haciendo un upload de cada foto, que eso le podría llevar mucho tiempo al usuario, 00:11:05

más fácil quizá 00:11:12

que el usuario le dé acceso 00:11:14

a esas fotos en el cloud 00:11:16

suyas 00:11:18

y pues presentárselas aquí en pantalla 00:11:19

que simplemente con un clic 00:11:22

unas cajitas de verificación diga pues 00:11:24

quiero esta y quiero esta y quiero esta 00:11:26

mejora mucho el servicio 00:11:27

mejora muchísimo la experiencia del usuario 00:11:30

que no tener que estar haciendo 00:11:33

cargas de las 00:11:34

fotos que tiene localmente 00:11:36

en su PC 00:11:38

vale 00:11:39

pero para hacer esto tenemos que involucrar aplicas a google tenemos que involucrarle de 00:11:41

alguna manera porque es el quien finalmente va a dar servicio a print fast para acceder a las 00:11:50

fotos de vamos a llamarle john juan juan entonces como como hacemos imaginaros yo en un principio 00:11:57

esto es print fast es una página que viene del servidor de print fast vale y juan yo soy juan 00:12:04

como usuario final y le doy a mi casa seleccionó cuál es el proveedor donde tengo mis fotos que 00:12:11

quiero que sean parte del álbum digo mi casa que ocurre en ese momento en ese momento lo que hace 00:12:19

print fast es reenviar mi navegador empezar como siempre yo le doy a aquí a le doy a picasa esto 00:12:28

va al servidor de picasa efectivamente y del perdón estaba el servidor de print fast y 00:12:41

efectivamente y ese servidor le manda una redirección al navegador vale no le manda 00:12:48

ninguna respuesta como página cargada sino que le hace un header location una redirección 00:12:54

a donde apunta esa redirección ahora se apunta a picasa así que el navegador lo que hace es bueno 00:13:00

le pide eso a print fast pero lo que recibe de print fast no es ninguna página sino es un mensaje 00:13:07

de print fast diciendo oye para resolver esa petición tienes que mandar otra petición a esta 00:13:12

nueva url y esa url sí que va a google sí que va a picasa para lo que antes era google fotos 00:13:18

es como de repente el navegador con este con este juego de redirecciones que hace el servidor el 00:13:27

navegador de repente en vez de estar apuntando por infas se le pide que apunte a picas vale 00:13:33

entonces ya donde pues al servidor de out 2.0 de picasa a una url donde picasa o google va a 00:13:40

a establecer un diálogo de autenticación con ese usuario pero como veis print fast ahora está fuera 00:13:49

del bucle no nunca va a poder capturar ni mis claves ni mi nombre de usuario con picasa porque 00:13:56

ya print fast no está para nada en esta petición nuestra petición sale directamente de mi navegador 00:14:05

hacia Picasa, hacia Google 00:14:12

¿vale? ¿qué hace Google? 00:14:14

pues coge el control, Google coge el control 00:14:17

y empieza a establecer un diálogo 00:14:19

conmigo, vale, ante esa petición 00:14:20

que yo le envío, que es fruto de una redirección 00:14:24

que me ha hecho Printfast 00:14:26

él pues envía, empieza a 00:14:28

mandarme información a mi navegador 00:14:30

¿vale? páginas dinámicas 00:14:32

con las que yo interacciono, y esas páginas 00:14:34

lo que me van a pedir es permiso 00:14:36

para decir, oye, hay una 00:14:38

aplicación que se llama 00:14:40

print fast que quiere tener acceso a tus fotos vale y posiblemente alguna información más a tu 00:14:42

perfil incluida tu foto tu dirección de correo de siempre se va quedando ahí con datos tuyos 00:14:51

pero bueno imaginaros principalmente tus fotos le quieres dar acceso y aquí el usuario pues tiene 00:14:59

esa posibilidad de decir no de alguna manera pues no no no quiere utilizar servicio print fast de 00:15:08

esta manera y lo venía o no dice mira me parece que voy a confiar en print fast principio a tener 00:15:14

acceso a mis fotos solamente a verlas pues le voy a dar acceso vale entonces en ese momento 00:15:20

google ya de alguna manera tiene que autorizar a print fast o tiene que permitir a print fast 00:15:32

o le va a permitir a print fast que pueda acceder a los datos de juan una vez que le ha dado acceso 00:15:40

como se hace eso nos hace con ciertos códigos con ciertos toques que llaman entonces una vez que yo 00:15:48

hago grant access vuelve en este caso google a utilizar ese mecanismo de redirección en vez de 00:15:54

mandarle una página para que cargue en el navegador en juan en el navegador de juan lo que hace una 00:16:02

redirección pero bueno pues ahora tienes que hacer es solicitar esta petición a esta otra url 00:16:08

qué url es pues este que tenemos aquí vuelvo a prinfas pero esta vez fijaros que lleva un código 00:16:17

esta url como atributo lleva un código asociado este es el código de autorización es el código 00:16:26

que va a utilizar printfast 00:16:35

se lo ha dado Google 00:16:37

con lo cual cuando printfast 00:16:39

empiece a utilizar este código 00:16:41

Google lo va a reconocer 00:16:43

y va a decir, este es el código que te di 00:16:45

porque previamente 00:16:46

Juan me dijo que efectivamente 00:16:48

te estaba dando permisos 00:16:51

para acceder a sus fotos 00:16:52

y veremos un poco la operativa 00:16:54

es un poco más compleja porque este código 00:16:57

luego hay que 00:16:58

cambiarlo o transformarlo 00:16:59

en un token 00:17:03

de acceso 00:17:03

¿vale? o sea que este código 00:17:05

de autorización no es solamente el dato 00:17:07

que se requiere para poder acceder a las 00:17:09

fotos de Juan pero si a partir de ese código 00:17:11

puedo solicitar un token de acceso 00:17:13

que es el que efectivamente luego me va a 00:17:15

permitir utilizar el API de 00:17:17

Picasa ¿vale? luego ya entra 00:17:19

en marcha 00:17:21

todas las posibilidades que tengo de 00:17:22

solicitarle cosas a Picasa utilizando un 00:17:25

API REST, API REST es básicamente 00:17:27

una URL 00:17:29

en un formato 00:17:31

concreto con una serie de partes dentro de la url establecidas para que cuando lleguen al servidor se 00:17:32

puedan interpretar y dependiendo de lo que se le está solicitando incluso parámetros que se 00:17:40

pueden introducir como partes de la url podrá satisfacer esa petición y devolver pues como 00:17:46

ocurría en ajax devolver un fichero con datos vale por aquí lo importante y para off es que 00:17:53

efectivamente a print fast y con este juego de redirecciones le llegue este código porque ya 00:18:00

con este código la aplicación de print fast ya va a poder empezar a trabajar desde el momento 00:18:07

que se hace la redirección pensar en esto en el momento que picasa la hace la redirección 00:18:15

al navegador esta es la petición que llega y esta petición llega a un script en este caso 00:18:20

al index.php 00:18:26

porque aquí no hay 00:18:27

ninguna ruta 00:18:30

hacia un script concreto, está al nivel 00:18:32

más alto, este es el 00:18:34

dominio y directamente ya 00:18:35

mete el atributo, es un ejemplo muy simplito 00:18:38

pero llegaría al index, vale, entonces 00:18:40

en el index, y esto es un 00:18:42

método get 00:18:44

siempre que estamos solicitando 00:18:45

información con la url directamente y con 00:18:47

los parámetros en la url, esto se 00:18:49

codifica como método get, como 00:18:52

mensaje get, entonces 00:18:53

iríamos a dolar get ahí encontraríamos este parámetro code y ya lo podemos procesar nosotros 00:18:55

en el servidor lo podríamos procesar y metiéndolo en la sesión para tenerlo disponible durante en 00:19:02

todas las interacciones que hagamos bien meterlo en una base de datos bien meterlo en el local 00:19:08

storage del navegador por eso ya un poco dependiendo un poco de la estrategia de manejo 00:19:13

de gestión de los tokens pero en principio esto ya una vez que se me redirige esto básicamente 00:19:18

esta petición sale del navegador de Juan hacia Printfast con estos datos, con estos parámetros. 00:19:25

Esto es importante porque no es del todo intuitivo estos cambios o estas redirecciones y cómo es posible que uno se entera 00:19:34

y cómo es posible que entran tres con un único navegador sin que el usuario realmente esté cambiando su URL, 00:19:41

sino que los mismos servidores van cambiando 00:19:48

o van redirigiendo al navegador de Juan 00:19:52

a un sitio u otro, dependiendo de si le toca intervenir 00:19:54

al servidor Auth de Google 00:19:57

o le toca intervenir al servidor de la aplicación PrintFast 00:20:00

y esta sería la última ventana 00:20:03

una vez que PrintFast ya tiene el código 00:20:08

pues ya puede, utilizando la API de Picasa 00:20:10

ya puede solicitarle a Google, oye pues dame las fotos 00:20:13

de este usuario 00:20:16

y una vez que la recibe 00:20:17

pues puede mostrárselas 00:20:20

al usuario 00:20:21

con estas cajitas 00:20:22

para que él diga 00:20:22

pues mira, quiero esta 00:20:23

quiero la primera 00:20:24

la tercera 00:20:24

la quinta 00:20:25

veamos un poco 00:20:25

¿eh? 00:20:28

cómo puede 00:20:28

cómo puede operar todo 00:20:29

vale, pues 00:20:30

yo creo que 00:20:31

he explicado 00:20:34

una segunda vuelta 00:20:35

¿eh? 00:20:37

todo esto se explicó 00:20:37

en la tutoría pasada 00:20:38

pero 00:20:39

yo creo que 00:20:40

si habéis visto 00:20:41

la tutoría 00:20:42

a lo mejor 00:20:43

todavía se os genera 00:20:44

alguna duda 00:20:45

esta vez 00:20:46

hemos 00:20:46

una segunda vuelta siempre como que viene bien para terminar un poco de asentar las 00:20:47

ideas para vamos a vamos a ver el playground entonces el playground es una aplicación que 00:20:56

ha hecho google esto sería print fast esta aplicación sería print fast yo sigo siendo 00:21:03

en este caso soy el usuario givan rock soy yo con mi usuario este sería print fast y google 00:21:10

tendría información mía distintos tipos y mediante alguno de estos apis yo voy a permitir que el 00:21:20

playground pueda acceder a mis datos que son privados le voy a dar acceso a mis datos que 00:21:31

son privados y que requeriría de alguna manera autenticación por mi parte para poder acceder a 00:21:37

ellos pero le voy a dar permiso a esta aplicación para que pueda hacer uso de ellos y pueda acceder 00:21:44

mediante una pires a esos datos a qué servicio a google estás google estás es una pequeña agenda 00:21:49

básica que todos tenemos y tenemos cuenta con gmail todos tenemos acceso a esa aplicación de 00:21:57

agenda y obviamente tú que te auténticas como ocurre aquí vale esta es la agenda está que 00:22:05

tengo aquí a la derecha entonces hay listas de tareas vale y puedo añadir una tarea pues 00:22:15

añado tarea título puede recoger en el colegio vale los detalles yo que sé puerta delantera 00:22:24

fecha puedo poner una fecha soy yo que sé 18 horas estas son las yo puedo ir añadiendo cosas 00:22:42

vale ya tengo aquí la de alta la tarea podría ir añadiendo más tareas entonces voy a hacer 00:23:05

ese ejercicio en el que le voy a dar permiso a playground para que pueda acceder en mi nombre 00:23:12

a esta esta información que es mía privada y que ningún otro usuario debería de poder acceder 00:23:19

vale como lo hacemos vale pues lo primero esta aplicación sigue una serie de pasos que son los 00:23:24

que normalmente se realizan en cualquier aplicación 00:23:30

para poder acceder a la información privada. 00:23:33

Aquí hay APIs que no son de ese tipo. 00:23:37

Por ejemplo, si accedes a Google Maps, 00:23:39

en principio Google Maps no es información privada de nadie, 00:23:42

es un servicio de Google. 00:23:46

Tú necesitas una clave que te da Google, 00:23:47

pero en principio tú estás accediendo a una capacidad 00:23:51

que tiene Google de poder proporcionarte un mapa, 00:23:54

pero no estás accediendo a la información de nadie. 00:23:57

No es lo mismo que si estás accediendo a los correos de una persona, a los vídeos de YouTube de una persona, a los mensajes de la red social de una persona. Todo eso sí que requeriría auth. Pero hay servicios generales que, en principio, si Google te da, tienes una clave que te da acceso y estás dado de alta y demás, si es el procedimiento habitual, pues, en principio, eso no sigue auth2. 00:23:59

tenéis que distinguir servicios que sí que necesitan dos y otros que no normalmente es 00:24:25

esa la idea si tú accedes a la información privada de alguien sí que lo necesitas porque 00:24:32

necesitas que sea alguien un momento dado de permiso si es un servicio genérico una plataforma 00:24:36

de búsqueda si le pides a google que te busque algo eso no requiere dos no estás entrando en 00:24:44

la información privada vale pues vamos a buscar google tasks como dice donde ha visto estos api 00:24:50

son api rest luego obviamente que alguna tiene su documentación tienes que conocerlo tienes que 00:24:56

saber cómo invocar lo tienes pero antes de invocar estos apis vamos a configurar y vamos a establecer 00:25:02

todo el mecanismo de 2.0 entonces venimos a google estás este vale hay dos opciones uno puede ser 00:25:11

tasks que puedo editar tareas o sea que si yo le doy esta posibilidad esa aplicación va a poder 00:25:25

crear tareas en mi agenda va a poder borrar las va a poder esto ocurre mucho por ejemplo con los 00:25:34

las aplicaciones de correo o de gestión de organización de tiempo que te dicen quieres 00:25:41

que te lo añada a tu calendar de google entonces si cierras una cita pues directamente encoge y 00:25:46

te lo de manera automática sin que entre estuve en tu calendar te lo te lo añade para que esa 00:25:54

aplicación funcione tú tienes que haberle posiblemente cuando lo instalaste te ha 00:26:01

ha pedido oye me das acceso a tu calendar de google de hecho sí porque prefiero que no tengo 00:26:07

nada que tan confidencial como para que una aplicación no lo pueda ver y en principio pues 00:26:13

agradezco que no tenga yo que hacerlo eso manualmente sino que directamente sea en todas 00:26:19

estas aplicaciones utilizan ese tipo de mecanismo para podemos coger tasks genérico aunque no vamos 00:26:24

a crear ninguna tarea vamos a ver un poco lápiz por encima pero vale entonces autorizó 00:26:29

Vale, hay que definir cuáles son los APIs que vas a usar. ¿Por qué? Porque cuando establezca Google, establezca la comunicación con el usuario, le tiene que informar qué es lo que, para lo cual tiene que dar permiso, ¿vale? No es un mensaje tan genérico como decir, oye, que alguien quiere hacer algo con tu información. ¿Le das permiso? No, no, tiene que decir con qué información es con la que efectivamente la aplicación va a contar. 00:26:37

Entonces, bueno, pues autorizo este scope. Eso normalmente se llama scope. ¿Veis? Aquí ya empieza la interacción conmigo, ¿vale? Entonces, fijaros que yo ya estoy dentro del navegador, con lo cual no me va a pedir autenticación. 00:27:03

Vale, quizá voy a salir, voy a cerrar para que veáis que si no, en principio me pediría, ¿vale? He salido, ya no estoy autenticado con el navegador. Ah, no, quizá sí, ¿vale? Porque lo que he hecho es salir. 00:27:18

Voy a entrar a modo invitado, voy a entrar como modo invitado, ¿vale? De tal manera que, ¿vale? Playground, voy a entrar de nuevo en Playground para que veáis que efectivamente me pide autenticación si es que no estoy aquí, ¿vale? 00:27:43

ahora ya no estoy autenticado con lo cual le digo a playground que quiere utilizar google 00:28:10

tasks que estaba quiero autorizar este api vale como veis me pide que inicie sesión 00:28:17

vale para que yo también pueda autenticar y decir si yo soy la persona que digo que 00:28:32

soy que él tiene que tiene que interactuar con el usuario final con juan entonces pues 00:28:38

vale 00:28:44

vale y ahora ahora es cuando él me está me está pidiendo permiso 00:28:53

ya no estoy ahora ya no estoy interaccionando con playground 00:29:08

interactuando con esta url que es una url de google donde de alguna manera gestiona 00:29:12

esos accesos de 00:29:22

Auth, ¿vale? Cuando 00:29:24

un usuario final tiene que dar esos permisos. 00:29:25

Entonces dice, confirma 00:29:29

que confías en Google Auth 2.0 00:29:30

Playground. Como veis, esta es la aplicación. 00:29:32

Esta es la aplicación. 00:29:34

Esto es PrintFast, una aplicación que está 00:29:36

programada en 00:29:38

te da una serie de historias 00:29:39

de, pues bueno, que sepas 00:29:42

de alguna manera que va a 00:29:44

tener acceso a eso y que 00:29:46

tengas eso claro, ¿no? Porque 00:29:47

alguien que no lee mucho los mensajes 00:29:49

pues puede dar 00:29:52

una serie de accesos, de permisos 00:29:53

que no son deseados 00:29:56

entonces te dice aquí lo que permites 00:29:58

permite que se creen, que se modifiquen, organizen 00:30:00

y eliminen tareas 00:30:02

de tu Google Tasks, vale yo lo voy a permitir 00:30:03

¿vale? pues 00:30:06

una vez que le he dado a permitir 00:30:11

fijaros que 00:30:12

mi navegador ha sido redireccionado 00:30:14

ahora vuelvo a otra vez 00:30:17

a estar direccionando 00:30:19

mi navegador hacia Playground 00:30:21

pero además 00:30:23

fijaros que le estoy enviando este código 00:30:27

el código 00:30:29

y el scope que es básicamente el API 00:30:31

para el cual ha sido autorizado 00:30:33

¿vale? y aquí tengo 00:30:35

el código de autorización 00:30:40

esto que aparece aquí es el código de autorización 00:30:41

¿es suficiente 00:30:44

ese código para poder ya solicitarle 00:30:46

información de mis tareas 00:30:48

a Google? no 00:30:50

¿vale? tiene que hacer un intercambio 00:30:52

del código de autorización por tokens 00:30:54

de acceso. Se hace como un doble 00:30:57

nivel de seguridad. 00:30:59

Una vez que tengo el código 00:31:01

puedo recibir un token. 00:31:02

¿Por qué? Porque estos 00:31:05

tokens expiran. 00:31:07

¿Veis que tenemos aquí 00:31:08

en el paso 2? 00:31:10

Tienes aquí una cuenta atrás 00:31:13

porque el token de acceso expira. 00:31:15

No es para siempre. 00:31:19

Pero si es verdad que hay 00:31:21

una manera de utilizar el API en la que 00:31:23

no solamente te envían 00:31:25

un código, perdón, no solamente 00:31:26

te envían un token de acceso, sino que 00:31:28

te envían también 00:31:31

un token de refresco. 00:31:32

Vale, y ese token de 00:31:36

refresco simplemente significa 00:31:37

que cuando esto caduca 00:31:39

yo no tengo que volver 00:31:40

otra vez a pedirle permiso al usuario, 00:31:42

sino que puedo utilizar este 00:31:45

token de refresco para volver a pedir otro 00:31:46

token de acceso con otra 00:31:48

duración de 00:31:50

en este caso una hora creo que es vale o sea que hay veces que se utiliza la pip simplemente para 00:31:52

utilizarlo una vez y otras veces que se pide este toque de refresco porque te permite no marear al 00:32:02

cliente cada poco pidiéndole ese permiso sino refrescando en el toque vale veis aquí tendríamos 00:32:07

una opción de auto refrescar el token y ese auto refresco se haría con este refresh toquen que 00:32:18

tenemos aquí vale ya tenemos nuestro token de acceso que es este de aquí ya podríamos solicitar 00:32:24

información desde playground podría entrar a la información privada de juan bueno pues vamos a 00:32:36

vamos a pedirle cosas como le pedimos información de las tareas utilizando la pirres y el api res 00:32:43

¿Qué es? Pues básicamente son mensajes HTTP. Puede ser GET, puede ser POST, PUT, DELETE. Normalmente estos mensajes tienen una semántica asociada. GET normalmente se utiliza para interrogar, para consultar, para solicitar información. POST, sin embargo, se utiliza para enviar. Si quiero que inserte algo, quiero que tome nota de algo, quiero que el API o el servicio de alguna manera reciba información desde el usuario, normalmente se envía por POST. 00:32:49

también puede ser algo 00:33:18

que permita de alguna manera 00:33:21

enviar datos, delete es para borrar 00:33:23

son peticiones de borrar, oye pues bórrame esto 00:33:25

en este caso por ejemplo 00:33:27

puede ser que para borrar una 00:33:28

tarea pues le pueda enviar un delete 00:33:31

y patch normalmente es 00:33:33

para cambiar, para 00:33:35

modificar cosas, es como 00:33:37

un modify 00:33:39

de por si 00:33:40

tienen cierta semántica 00:33:42

porque pensar todo el 00:33:45

API y 00:33:47

toda la semántica de las operaciones 00:33:49

tiene que 00:33:51

integrarse en el 00:33:52

protocolo HTTP. Esa es la grandeza 00:33:55

de REST, que no necesitas más niveles 00:33:57

por encima. Con HTTP 00:33:59

te apañas. 00:34:01

¿Qué tiene HTTP? Pues el tipo 00:34:03

del mensaje y obviamente 00:34:05

el mensaje sí, el mensaje en sí. 00:34:07

Y el mensaje en sí normalmente es 00:34:09

la URL, puede 00:34:10

ser un cuerpo donde 00:34:13

están los datos y unas cabeceras. 00:34:15

Acordaros un poquito de lo que o cómo se planteaba un mensaje HTTP, pero tampoco tiene mucha más variación, ¿vale? 00:34:17

Entonces, puedo jugar con el tipo del mensaje y puedo jugar efectivamente con lo que escribo dentro de la URL, los parámetros que añado. 00:34:27

Eso es un poco el juego que me da. 00:34:36

Recordar también, los API REST, otra característica importante es que no dependen de ningún estado, ¿vale? 00:34:38

No pueden depender de cosas que pasaron antes, porque HTTP no tiene memoria. No está dentro de ninguna operativa que sepa que anteriormente ha pasado por tal mensaje antes de llegar al otro o que se ha intercambiado tal información. Eso en HTTP no ocurre. Cada mensaje es uno nuevo y se procesa como uno nuevo, sin tener en cuenta nada que haya pasado anteriormente. 00:34:45

Vale, pues vamos a ver, aquí te da una ayuda, ¿no? Si no sería un poco complicado, habría que acordarse de esos mensajes. Entonces, aquí te da una ayuda con las posibles operaciones que puedes realizar en este API de Google Tasks, que es el que vamos a utilizar, el que hemos autorizado. 00:35:07

entonces tenemos cosas que tienen que ver con 00:35:28

task list, es decir 00:35:31

con listas de tareas 00:35:32

acordaros que teníamos aquí 00:35:34

había listas de tareas 00:35:36

lo he cerrado 00:35:38

el otro, lo he cerrado con un montón 00:35:42

de cosas, vale, dejarme 00:35:44

que lo 00:35:46

abra 00:35:46

tenía preparado aquí un montón de cosas 00:35:48

vale, vamos a entrar en gmail 00:35:51

vuelvo a estar aquí, estas son mis tareas 00:35:56

entonces, estas son listas 00:36:07

de tareas 00:36:09

y si ya entro en alguna de ellas 00:36:10

pues estas son tareas dentro de las listas de tareas 00:36:13

vale, entonces 00:36:16

pues vamos por ejemplo a ver 00:36:17

cuántas listas de tareas tengo 00:36:21

vale, entonces esta operación 00:36:23

fijaros que va 00:36:25

a este dominio 00:36:26

y esto todo ya es parte 00:36:29

de 00:36:31

lo que en realidad 00:36:32

bueno 00:36:35

vamos a obtener las listas de tareas 00:36:37

primero, yo creo que para eso en realidad 00:36:39

no es get task list sino list 00:36:41

vale, vamos a listarlas primero 00:36:43

vale, como veis aquí 00:36:45

hay cosas dentro, esto es básicamente 00:36:47

se va a sustituir 00:36:49

por mi usuario id 00:36:51

dentro de google y vamos a hacer 00:36:52

alguna que sí que tenga que meter ahí algún 00:36:55

parámetro como el ID 00:36:57

de la lista de tareas, pero de momento vamos a listarlas 00:36:58

¿vale? Entonces enviamos la petición 00:37:01

esto va a ir acompañado del token 00:37:03

aunque aquí no se vea, pero el token 00:37:06

obviamente este de acceso también viaja para que 00:37:09

se verifique y si se envía, pues aquí 00:37:11

tengo la información que me llegó 00:37:13

Google me lo ha, desde Playground 00:37:14

una aplicación 00:37:17

le ha permitido 00:37:18

acceder a toda esta información mía privada 00:37:20

¿vale? Porque hemos 00:37:23

seguido el proceso de OZ2 00:37:25

antes de llegar a este punto. 00:37:28

Y aquí tienes las listas de tareas, pues lista 00:37:30

de Hibam Robot, repartos 00:37:31

y todas estas listas de 00:37:33

tareas que luego ya entenderéis 00:37:35

por qué se llaman así, porque están dentro 00:37:38

de la aplicación de repartos 00:37:39

que es la que vamos a decir. 00:37:42

Iván, te puedo hacer una pregunta. 00:37:43

Sí, es que para entenderlo 00:37:46

un poco, porque también vi la clase esta 00:37:48

el otro día, lo que veo es que esto es 00:37:49

como si tuvieras 00:37:51

una API personal 00:37:53

que está encriptada con una clave 00:37:55

quiero decir que 00:37:58

puedes tratarlo como una API de tareas 00:37:59

que tiene endpoints en las que 00:38:02

pides una tarea o haces cosas 00:38:04

con tareas, solo que bueno 00:38:06

como son mis tareas, pues le tengo que dar una clave 00:38:07

para que pueda acceder a diferencia 00:38:10

de APIs públicas tipo 00:38:12

datos meteorológicos 00:38:13

claro, claro, sí, ahora 00:38:15

entiendo lo que dices como API personal, efectivamente 00:38:18

es un API que entra a datos personales 00:38:19

es una API 00:38:21

que te permite acceder a datos privados de otro usuario, desde una aplicación, sin que ese usuario realmente sea el que está solicitando los datos, 00:38:23

porque los datos ahora los está solicitando Playground. Y Google, como hemos pasado por ese paso intermedio de que me ha pedido permiso 00:38:35

yo se lo he dado, Google 00:38:46

ya sí que le permite a Playground 00:38:48

entrar a 00:38:50

consultar mis datos a Playground 00:38:52

que de otra manera 00:38:54

sería imposible, ¿no? Que Google le diera 00:38:56

acceso a nadie, ya sean otros 00:38:58

usuarios o incluso aplicaciones 00:39:00

que le pudieran dar acceso a mis datos 00:39:01

no tendría ningún sentido, ¿no? 00:39:04

Sin yo 00:39:05

tener 00:39:07

¿sabes? Sin tener 00:39:08

mi permiso, mi aprobación 00:39:13

Sí, efectivamente. En realidad son APIs de servicios, no es algo que solamente puedas utilizar una persona, es un API definido, documentado, pero sirve para acceder a datos. 00:39:15

Como dices, hay otros servicios que no necesitan este proceso previo de permisos para solicitar un mapa o para solicitar información meteorológica o para solicitar datos generales de clima. Todo eso no requeriría hacer optos porque no estás entrando a los datos de nadie. Estás entrando a los datos que te ofrece un servicio web que tiene esa posibilidad. 00:39:31

Vale, pues sí, pero aprovechar para hacer esa pregunta. Y si todavía no encajo bien mi respuesta con vuestro modelo mental, seguir ahondando en las preguntas hasta que yo dé quizá con la respuesta o confirme que lo que vosotros tenéis en la cabeza es realmente lo que intento describir. 00:40:00

Bueno, no os quedéis con dudas, porque ahora es el momento. Bueno, yo tengo un modelo en la cabeza y me está contando cosas que parece que sí, pero todavía cosas que no me encajan. Necesito encajarlo del todo. Bueno, pues, hacerme preguntas de ese tipo porque son las que realmente os permiten tener la base bien entendida. 00:40:27

vale, bueno pues 00:40:48

esta es 00:40:50

un archivo de datos 00:40:53

que viaja 00:40:55

de vuelta al navegador 00:40:56

en este caso 00:40:59

a la aplicación 00:41:00

en este caso posiblemente 00:41:03

yo estoy ejecutando aquí una aplicación 00:41:04

esto puede viajar o bien a un servidor 00:41:06

o bien puede viajar directamente 00:41:09

al cliente 00:41:11

la conexión, los API REST 00:41:12

se pueden utilizar, nosotros vamos a utilizarlos 00:41:15

algunos los de los dos los vamos a utilizar en php o sea que sería el servidor php durante la 00:41:18

ejecución del script el que se comunicaría con google tasks pero podríamos utilizarlo desde el 00:41:26

mismo javascript que está corriendo en el cliente aquí hay dos posibilidades los del servidor o 00:41:34

directamente desde el cliente con lo cual el cliente directamente decía el otro día coge 00:41:40

el control, ya no necesita el servidor 00:41:45

para el que le vaya a buscar esta información, 00:41:47

sino que él directamente 00:41:49

establece este mecanismo 00:41:50

y una vez que tiene el token, 00:41:52

directamente desde Javascript puede solicitar 00:41:55

la información a Google Tasks. 00:41:57

Y se salta. 00:41:59

Todo el paso intermedio, toda la 00:42:01

comunicación con el servidor 00:42:03

desde el que se ha descargado 00:42:04

el Javascript. El servidor de 00:42:09

Printfast, en este caso el servidor de Playground. 00:42:10

Vale, pues 00:42:14

aquí tendría la información 00:42:14

esto todo está documentado 00:42:17

luego veremos un poco 00:42:18

aunque 00:42:19

por alguna razón 00:42:20

sí 00:42:21

esta documentación 00:42:22

no está del todo 00:42:24

clara de Google Tasks 00:42:25

a lo mejor no es un servicio 00:42:26

así muy útil 00:42:27

pero vamos a ver 00:42:27

dentro de las páginas 00:42:28

que tiene Google 00:42:29

de Google Tasks 00:42:30

vamos a ver un poquito 00:42:31

la documentación 00:42:32

y aquí te viene 00:42:33

Task List 00:42:34

vamos a entrar 00:42:35

a ver una Task List 00:42:36

concreta 00:42:37

entonces 00:42:38

fijaros que 00:42:38

la Task List 00:42:39

tiene este ID 00:42:41

y me va a servir 00:42:42

para pedirle 00:42:42

al API 00:42:44

que me dé las tareas 00:42:46

dentro de esta task list, ¿no? 00:42:48

Entonces, entro aquí en las posibles operaciones 00:42:51

y digo, dame las tareas, ¿vale? 00:42:53

Va a ser esta. 00:42:56

Returns, authenticated users, specified, 00:42:57

no, task list, insert, update, clear, delete, 00:43:00

¿qué task? 00:43:04

Vamos a ver esto. 00:43:05

Sí, no, pero necesito una tarea. 00:43:07

Vamos a ver esto, ¿qué task list? 00:43:09

Vale. 00:43:12

Entonces, aquí veis que tiene esta parte entre llaves, ¿vale? 00:43:13

la voy a sustituir por el id de la task list como veis voy metiendo dentro de la url voy metiendo 00:43:17

parámetros también voy metiendo datos que luego cuando llegan al servidor se extraen de la url y 00:43:25

se utilizan para que mi consulta sea concreta sobre una task list determinada no sobre cualquiera 00:43:33

Tengo que decir sobre cuál es sobre la que quiero enviar la consulta. Vale, envío la petición y aquí la tengo, ¿veis? Y aquí tengo mi tarea. Ah, no, no, no, en realidad, aquí tengo información de mi task list, ¿vale? Definida sobre una concreta. 00:43:42

Entonces, vamos a ver cómo puedo listar updates, returns, listas. Vale, estaba así. Vale, entonces, para ver las tareas dentro de esa task list, utilizo esta operación. 00:43:56

si lo envío, aquí me llega 00:44:14

lo que metí antes, recoger a niños 00:44:17

en el colegio, la puerta 00:44:19

delantera, la hora, etc 00:44:21

y también 00:44:23

la task, la tarea en sí, también tiene 00:44:25

un identificador, por si quiero 00:44:27

establecer algún tipo de información 00:44:29

vamos a ver si puedo cambiar 00:44:32

por ejemplo, en esta tarea 00:44:33

utilizando el API 00:44:35

update 00:44:37

esto va a ser complicado porque tendría que 00:44:39

escribir 00:44:44

request. ¿Ves? En update 00:44:45

manda un put. 00:44:48

Vale, manda un put. 00:44:51

Pero tendría que escribir 00:44:54

informaciones 00:44:56

Json para describir el cambio. 00:44:58

Bueno, yo creo que para el ejemplo no 00:45:00

va a ser necesario. ¿Ven? Para que cojáis 00:45:02

un poquito la idea. 00:45:04

¿Ven? 00:45:06

De cómo he seguido todo el proceso 00:45:07

hasta conseguir 00:45:10

poder interaccionar con Google 00:45:12

para que me enviara la información del usuario final vale alguna pregunta entonces sobre esta 00:45:14

operativa no sé si se me escucha ahora sí no es que estaba intentando seguir un poco lo que 00:45:25

estabas haciendo iván pero no me sale la opción de elegir en el paso 3 de listas de operaciones 00:45:34

¿Me falta algo más ahí? 00:45:41

Está abajo, mira a ver si está aquí abajo 00:45:43

A ver 00:45:45

Claro, yo veo 00:45:47

Que tú, efectivamente, a ti te sale la opción 00:45:49

De elegirlo, pero 00:45:51

A mí me parece como en gris, sin posibilidad de 00:45:52

Aquí, en el primer paso 00:45:55

En el de selección 00:45:57

Authorize APIs 00:45:58

No, en el tercero 00:46:00

En el tercero 00:46:01

Cuando dices configure 00:46:03

Request 00:46:05

Donde sale está en request 00:46:06

te sale la opción de lo que estabas hablando antes, 00:46:09

lo de elegir operaciones. 00:46:11

A mí no me sale. 00:46:13

¿Has seleccionado, has autorizado los APIs primero? 00:46:14

Sí. 00:46:17

Has venido aquí. 00:46:18

Comprueba que tienes esto marcado en Google Tasks. 00:46:19

Ah, vale. 00:46:23

Vale, quizá por... 00:46:24

Sí, seguramente es por eso. 00:46:24

Perfecto, vale, gracias. 00:46:26

Vale, vale. 00:46:27

Me lo has sacado de ahí. 00:46:27

También, para que los veas, entra en tu agenda y mete cosas. 00:46:28

Vale. 00:46:33

Para ver que efectivamente te puede traer lo que tengas allí metido. 00:46:34

Perfecto, gracias. 00:46:38

Vale. 00:46:39

Eh, bueno, vamos a, vamos a verlo desde el código. Vale, vamos a verlo desde el código. Eh, para lo cual vamos a poner, vamos a borrar quizá para que veamos un poco cómo se me pide la autorización. 00:46:39

Voy a borrar por si acaso queda algún, yo creo que no va a quedar ningún token en la sesión de alguna ejecución previa, pero voy a mirar aquí en las herramientas, herramientas para desarrolladores, vale, no parece que haya ninguna cookie de sesión de PHP, con lo cual supongo que me va a volver a pedir autorización. 00:47:00

entonces voy a depurarlo 00:47:29

voy a colocarme aquí en el index 00:47:31

no os preocupéis, luego vamos a hablar 00:47:33

de la aplicación un poquito más en detalle 00:47:37

de momento solo quiero que veáis 00:47:39

cómo se hace este intercambio 00:47:41

dentro del código y cómo se hace esta operativa 00:47:43

para hacer todo esto 00:47:45

desde PHP necesitas 00:47:49

una librería 00:47:51

una librería PHP que la programa 00:47:52

Google, se llama Google Client 00:47:55

entonces como veis aquí en el 00:47:57

Composer, en la definición 00:47:59

de Composer Json, está 00:48:02

la librería 00:48:04

Google Client, ¿vale? 00:48:05

Entonces, bien podéis 00:48:08

añadir esto a mano o bien podéis 00:48:10

hacer un Require, 00:48:11

Composer Require para instalarla. 00:48:13

Yo en la 00:48:17

última versión, creo que es la 2.12, 00:48:18

yo creo que puse la última. 00:48:20

Y luego aquí hay una serie de 00:48:21

añadidos 00:48:23

a Composer que básicamente 00:48:25

tienen que ver con que cuando te la descargues no se descarguen todos los apis rest o la parte 00:48:27

cliente del api red de todos los servicios de google sino solamente de los que vayas a usar 00:48:36

vale si no pones esto él se descarga todos los clientes es decir pensar que ahora como pasaba 00:48:41

con SOAP, yo voy a establecer 00:48:50

peticiones desde mis scripts 00:48:52

PHP hacia el servidor 00:48:54

de Google, ¿no? Y que 00:48:57

de alguna manera maneja ese servicio. 00:48:58

Igual que ocurría con SOAP 00:49:03

cuando hacíamos, a partir del WSDL 00:49:04

generábamos un objeto de servicio, 00:49:07

un objeto cuyos métodos 00:49:09

eran realmente las peticiones 00:49:11

que le enviábamos desde el cliente al servidor, 00:49:12

aquí ocurre lo mismo. Esta librería 00:49:14

de PHP de Google 00:49:16

me va a facilitar el uso 00:49:18

de este API y en vez de tener que utilizar yo las direcciones 00:49:20

URL, HTTP, como pasaba en el 00:49:25

Playground, me lo va a simplificar. ¿De qué manera? Bueno, pues me va a dar 00:49:28

unos objetos que yo voy a instanciar cuyos 00:49:32

métodos directamente se van a codificar 00:49:36

como digo, a mí me va a ofrecer construir objetos 00:49:40

de unas clases y sobre esos objetos voy a poder invocarle 00:49:44

métodos luego internamente esa librería esos métodos lo que van a hacer es establecer la 00:49:48

url correspondiente a la función de ese método y enviársela al servidor pero todo eso a mí como 00:49:55

usuario de ese api me es transparente yo la operativa que tengo desde php es muy sencilla 00:50:01

es instancia del objeto y le invocó un método elite de todo en este básicamente que se se 00:50:08

mapean muy bien con lo que teníamos 00:50:17

aquí, con estas operaciones 00:50:20

¿vale? con estas operaciones de aquí 00:50:21

pero en vez de yo 00:50:24

tener que escribir todo esto 00:50:26

de aquí, que podría ser un poquito 00:50:29

podría meter errores 00:50:31

etcétera, etcétera, porque en realidad 00:50:33

el API REST es enviarle 00:50:35

este mensaje HTTP al 00:50:37

servidor, eso es realmente lo que 00:50:39

es el API REST 00:50:41

pero en vez de tener yo que escribir todo 00:50:42

esto, lo que me hace es 00:50:45

me construyo un objeto 00:50:46

pues posiblemente un objeto task list 00:50:48

y al que 00:50:51

le puedo invocar 00:50:53

estos métodos, me paso como parámetros 00:50:54

de entrada al método los datos que 00:50:56

tiene que ir 00:50:58

incrustando en la url 00:51:00

y a mi me hace la vida 00:51:02

bastante más fácil, bueno pues ese código 00:51:04

esa librería de cliente 00:51:07

ya es la que proporciona 00:51:08

google, pero 00:51:11

si yo no le pongo esto en el 00:51:12

composer, el me instala 00:51:14

a todos los clientes de todos los servicios. 00:51:17

Finalmente, la distribución del código es muy grande 00:51:21

para cosas que nunca voy a utilizar 00:51:24

porque solo voy a utilizar tasks, ¿vale? 00:51:25

O sea que si utilizas este extra, 00:51:27

te dices, mira, de los servicios de clientes, 00:51:30

solo quiero que me instales tasks. 00:51:33

Solamente te va a incluir ese servicio. 00:51:36

Vale. 00:51:39

Listo. 00:51:40

Con lo cual, tenemos un módulo más, 00:51:41

una librería más 00:51:43

que descargamos de Google 00:51:45

esto lo programa Google 00:51:48

entonces 00:51:50

decía, vamos a 00:51:54

depurar el código 00:51:56

para que veáis como nos va a funcionar 00:51:58

vale, vamos a empezar aquí 00:52:00

vamos a empezar aquí 00:52:01

y vamos a depurarlo 00:52:04

y vamos a ir ejecutándolo poco a poco y os digo un poquito 00:52:06

que hace cada parte del código 00:52:09

ah, perdón, dejarme que arranque 00:52:12

la base de datos y no lo funciona porque en la primera en la primera 00:52:15

en la primera versión no necesita base de datos pero si en la segunda si está 00:52:28

ya en la versión final entonces si no arranca la base de datos 00:52:33

lo tengo parado aquí acordaros en la sesión anterior en la sesión anterior 00:52:41

otra cosa importante que hicimos fue configurar nuestra cuenta de aplicación con google para 00:52:48

solicitar credenciales vale o sea que esto no es tan sencillo como bueno yo soy fulano dale 00:52:58

permisos o consulta juana a ver si quiere que yo entre no no no previamente yo como playground o 00:53:04

como print fast como en este caso esta aplicación de repartos tengo que ir a google y tengo que 00:53:12

registrarme dice yo soy la aplicación repartos y voy a utilizar este mecanismo de poder acceder a 00:53:18

información del usuario final si es que él me da permiso y eso lo hicimos en la tutoría pasada 00:53:27

añadimos información configuración de la venta de la ventana de consentimiento esa ventana que 00:53:33

se retorna al usuario porque es configurable vale para que sea un poquito más personalizada para que 00:53:39

yo pueda poner mi logo pueda poner informaciones que yo pueda entender que son interesantes de 00:53:44

cara a mejorar ese diálogo y luego además pongo información de la redirección que va a hacer 00:53:49

google hacia mi sitio web vale cuando en este momento que teníamos aquí este momento importante 00:53:56

En el que, vale, yo le he dado permiso y en el momento que le doy permiso, 00:54:06

Picasa redirecciona el navegador a mi web. 00:54:13

Bueno, pues esta dirección, esta URI, que llamo URI de redirección, 00:54:17

también la he tenido que configurar cuando me he dado de alta en el Google Developer Console. 00:54:22

Lo que hicimos en la tutoría pasada. 00:54:29

Es otra manera de comprobar que efectivamente está en sincronía, coincide lo que configuró la persona que registró la aplicación, coincide con lo que efectivamente o el sitio donde finalmente se están esperando que lleguen estos datos, ¿vale? 00:54:31

Porque aquí voy a configurar qué script, puede ser el index si es que no pongo nada o puede ser un script concreto, es el que va a recibir estos datos. Y eso tiene que coincidir. Si no coincide, de alguna manera no funciona porque lo que va a hacer Google siempre va a ser redirigir al navegador a una URI que está configurada en ese registro de la aplicación con Google. 00:54:52

o sea que hay cosas 00:55:17

si no os funciona, pues no 00:55:20

tenéis que comprobar que todo eso coincide, es muy importante 00:55:21

si no hay un 00:55:24

error y no se 00:55:25

lleva a cabo la comunicación 00:55:28

aparte que se hacen esas comprobaciones de 00:55:29

seguridad, efectivamente 00:55:32

eso es así 00:55:34

y que coincide con lo que tú lo has configurado 00:55:35

vale 00:55:38

cuando hicimos el 00:55:39

registro de la aplicación 00:55:41

descargamos unos credenciales 00:55:43

un ficherito Json 00:55:45

que me daba la opción de descargarlo 00:55:47

eso lo necesitamos 00:55:50

porque son los credenciales con los que 00:55:51

yo voy a también interaccionar con 00:55:54

Google y con los servicios de Google 00:55:56

yo soy la aplicación 00:55:57

Tracatrac con este 00:55:59

credencial, ¿por qué? 00:56:01

por control también, porque Google 00:56:03

tiene que saber cuantas veces le estoy pidiendo las cosas 00:56:05

porque si paso en un límite 00:56:08

me va a cobrar 00:56:10

entonces Google cada vez que 00:56:10

hago un registro, de alguna manera 00:56:14

me tiene identificado, ¿vale? Mis credenciales 00:56:16

me identifican 00:56:18

para que yo no pueda exceder un poco 00:56:18

el uso que tengo acordado con Google. 00:56:21

Si es que he pagado una tasa, pues 00:56:23

si he pagado una tasa. Si es que tengo un acceso gratuito, 00:56:25

que es lo que estamos haciendo ahora, estamos 00:56:27

accediendo con este 00:56:29

digamos nivel gratuito, que son 00:56:31

muy pocas peticiones, pero suficientes como 00:56:33

para probar 00:56:35

la aplicación. 00:56:37

Pero él sabe que yo estoy accediendo. 00:56:39

No es gratuito, venga, tú haz lo que 00:56:42

quieras, no, no, él tiene control sobre ti 00:56:43

te da unas credenciales y tú tienes que 00:56:45

atenerte un poco a Zeus 00:56:47

vale, pues esto sale del entorno 00:56:48

y el entorno, acordaros, es este ficherito 00:56:51

.ef, no lo voy a visualizar 00:56:53

bueno, no lo voy a visualizar 00:56:55

porque hay claves 00:56:57

aquí es donde van a parar todas las claves 00:56:59

de todos los APIs 00:57:01

como yo creo que os enseñé también 00:57:02

en la auditoría pasada 00:57:05

entonces 00:57:06

ahí es donde tenéis que ir dando de alta 00:57:08

tenéis un ejemplo 00:57:11

.env.ejemplo 00:57:13

que os dice los nombres de los campos 00:57:15

y luego ya tenéis que 00:57:18

rellenar ese ficherito de configuración 00:57:19

con vuestras claves 00:57:22

ir a cada sitio, ir a Big Maps 00:57:23

ir a OpenWeather 00:57:26

si es que queréis 00:57:28

vosotros también ejecutar el código 00:57:28

de OpenWeather, en todos esos sitios 00:57:32

os registráis y 00:57:34

gratuitamente os van a dar las claves 00:57:36

de alguna manera lo necesitáis 00:57:37

también para que estas aplicaciones 00:57:40

funcionan, si no ningún proveedor 00:57:42

os va a dar acceso a sus servicios 00:57:43

vale 00:57:45

pues vamos a hacerlo correr, aquí tengo ya las 00:57:46

credenciales, fijaros en 00:57:50

el URI, vale 00:57:52

el URI que tenemos nosotros 00:57:53

es http://localhost 00:57:55

8000 00:57:58

¿qué hay aquí? 00:57:58

aquí tenéis que poner donde está ejecutando 00:58:01

el script 00:58:04

que tiene que recibir 00:58:06

el código, en este caso es index 00:58:09

index.php va a recibir el código 00:58:11

Y este es el sitio donde está ubicado. Fijaros que pone 8000. ¿Por qué? Porque estoy trabajando con el servidor interno de NetBeans. Si lo tuvierais alojado en Apache, el URI, tanto cuando registráis la aplicación como aquí en este parámetro, tenéis que direccionarlo a donde tengáis desplegada vuestra aplicación en Apache. 00:58:13

que puede ser http://localhost 00:58:37

barra y el nombre 00:58:40

de la carpeta donde hayáis puesto vuestro proyecto 00:58:44

el tws08tarea 00:58:46

pero tiene que estar 00:58:49

redirigido a la ubicación 00:58:53

donde está el script 00:58:57

al que va el navegador a solicitarle 00:58:58

oye pues ahora me han pedido 00:59:03

que te contacte a ti y que te envíe 00:59:06

Obviamente con esta URL que lleva este parámetro de código asociado para hacerte llegar este código. 00:59:08

Sí, o sea que esto es importante. 00:59:16

¿Se entiende más o menos esta jugada de los URIs y la de redirección? 00:59:17

¿Se intuye? 00:59:23

Va, perfecto. 00:59:25

Vale, una vez que tengo ya estos parámetros, ya puedo crear una instancia de Google Client. 00:59:26

Acordaros. 00:59:32

acordaros 00:59:32

que todo esto es orientado a objetos 00:59:38

¿vale? de nuevo, todos los APIs 00:59:42

que encontráis ya modernos 00:59:44

todos van orientados a objetos 00:59:46

entonces aquí ya no hay funciones 00:59:48

aquí siempre funciona de la misma manera 00:59:50

tienes un API que significa 00:59:52

un conjunto de clases 00:59:54

que puedes ir instanciando objetos de ellas 00:59:55

y que invocándole 00:59:58

métodos a los objetos que has instanciado 01:00:00

te dan la funcionalidad 01:00:02

¿vale? de ese app 01:00:04

entonces, esta librería Google Client 01:00:05

pues ¿cómo la vamos a usar? instanciando 01:00:08

un objeto, como hacíamos 01:00:10

con SwapServer o SwapClient, todo esto 01:00:12

al final son clases 01:00:14

de las cuales instancias objetos y le 01:00:16

invocas métodos 01:00:18

vale, pues a este cliente que creas, le vamos 01:00:19

asociando distintos 01:00:22

datos, vale, vamos a ir corriendo 01:00:24

el script 01:00:26

paso a paso, hemos creado, pero bueno 01:00:28

Le podemos ir dando información de cómo se llama la aplicación. 01:00:30

Le vamos a dar información de cuáles son mis credenciales con 01:00:34

este método set of config, ¿vale? 01:00:38

Le doy el ficherito, ese json que me bajé cuando creé las 01:00:40

credenciales. 01:00:44

Le doy información del redirect URI. 01:00:45

Este tiene que coincidir, repito, 01:00:48

tiene que coincidir con el que configure cuando configure la 01:00:50

redirección en Google, en la consola de Google. 01:00:54

¿Vale? 01:00:59

Y también le configuro cuál va a ser lo que va a requerir como permiso. 01:00:59

El scope, básicamente, significa cuando tú vayas a pedirle permisos al cliente final, 01:01:07

¿sobre qué le vas a pedir permisos? 01:01:13

¿Vale? 01:01:15

Y con esta constante, yo le estoy diciendo que tiene que pedir permisos para gestionar sus tareas. 01:01:15

¿Vale? 01:01:22

Si fuera cosas de Gmail, pues aquí cambiaría. 01:01:22

Sería service, Gmail, ta, ta, ta. 01:01:24

O YouTube. 01:01:26

o lo que en principio 01:01:27

necesitar 01:01:29

vale 01:01:30

le digo set access type offline 01:01:32

esto es para poder refrescar el token 01:01:35

vale, quiero un token de refresco también 01:01:37

le voy a solicitar un token de refresco 01:01:39

y set prompt 01:01:40

es para que efectivamente 01:01:43

pida consentimiento, vale, que no sea un proceso 01:01:44

distinto 01:01:47

sino que le presente la ventana 01:01:49

de consentimiento al usuario para poder 01:01:51

yo luego acceder a sus datos 01:01:53

vale 01:01:54

Y ahora empieza el script, ¿no? Y aquí tengo varias casuísticas. Acordaros siempre de el script arranca y tiene que ir averiguando en qué casuística está. Este es index, ¿vale? Con lo cual, yo no sé, puede ser que esté ejecutando en un momento cuando en realidad está llegando la redirección de Google y dentro de la URL tiene este parámetro code. 01:01:56

Es decir, viene algo en $GET de CODE, ¿vale? 01:02:23

Os vuelvo a poner este, ¿no? 01:02:30

Imaginaros que estoy aquí. 01:02:32

Si yo he mandado esta petición a un script PHP, $GET de CODE va a tener este dato, con lo cual va a ser inset. 01:02:35

Y esto va a dar true, o sea, que va a entrar por esta rama, ¿vale? 01:02:45

¿Ese es el caso? 01:02:51

No, de momento no es el caso, porque todavía no se le ha pedido la solicitud de permiso al cliente final, con lo cual, $GET no tiene datos. Si lo vemos, tiene el dato del debug, pero no tiene el código todavía, porque obviamente todavía el usuario no le ha dado el permiso a Google para que yo pueda acceder en su nombre o para que repartos pueda acceder a su nombre. 01:02:52

con lo cual esto se va a saltar 01:03:18

vamos al otro iset 01:03:22

puede ocurrir otro escenario 01:03:24

es en el que 01:03:26

ya me ha llegado el código 01:03:28

y lo he guardado en la sesión 01:03:30

que es como lo voy a implementar 01:03:33

en esta aplicación, hay otras 01:03:35

de implementarlo, de guardarlo en una base de datos 01:03:36

o guardarlo en otros medios 01:03:38

persistentes para que no se pierda 01:03:41

entre petición y petición 01:03:43

yo aquí, un método muy sencillo es guardarlo en la sesión 01:03:44

¿cuándo ocurre esto? 01:03:47

Bueno, pues cuando ya me ha llegado, lo meto en la sesión y me siguen llegando peticiones para yo necesitar acceder a tareas, pero en vez de tener que volver otra vez a solicitar el token a Google, como lo tengo en la sesión, lo cojo y con ese token ya puedo establecer de nuevo las peticiones a tasks. 01:03:49

ese es el caso, no, porque sesión 01:04:07

en principio está vacía 01:04:09

no hay nada en la sesión de 01:04:11

de PHP 01:04:15

con lo cual este tampoco es el caso 01:04:16

lo saltamos, vamos a este 01:04:19

y si no, ya aquí, este sí que 01:04:21

va a ser el caso, lo que voy a hacer 01:04:23

es crear la URL 01:04:25

que va a redirigir 01:04:27

al navegador 01:04:29

para que empiece la comunicación 01:04:30

2.0 con Google 01:04:33

¿vale? este paso 01:04:35

es este de aquí, ¿vale? 01:04:37

Este paso es este de aquí. 01:04:39

Este primer paso en el que 01:04:43

una vez que el usuario dice, 01:04:45

vale, pues quiero entrar en Picasa, 01:04:49

lo que hace PrintFast es decir, 01:04:51

vale, pues habla con Picasa. 01:04:52

Y esta URL de aquí, 01:04:55

que es a la que se redirecciona 01:04:57

al navegador, es justo 01:04:58

esta URL que se crea 01:05:00

automáticamente, que yo no tengo que 01:05:03

construirla porque es una URL un poquito 01:05:05

larga y compleja, pero con este 01:05:07

método del cliente me la crea 01:05:09

automáticamente. Vale, de hecho 01:05:11

si yo le doy un paso 01:05:13

y miro cuál es el... 01:05:14

¿Ves? Es una URL compleja. 01:05:17

Tiene mis... 01:05:20

Vale. 01:05:21

Vale, ¿sí? 01:05:24

Es una URL compleja. 01:05:25

Listo. 01:05:30

Y con esa URL 01:05:32

lo que hago es 01:05:34

hacer la redirección 01:05:36

aquí es donde le pido 01:05:38

al navegador 01:05:39

que redireccione 01:05:41

hacia esa url que he creado 01:05:43

con este método 01:05:46

que me da la librería de google 01:05:47

con lo cual 01:05:50

lo que voy a conseguir es que el navegador 01:05:52

directamente 01:05:54

coja y envíe 01:05:56

en vez de recibir una página 01:05:57

esta petición que ha hecho inicial 01:06:00

en vez de recibir una página del servidor 01:06:02

creada por este script 01:06:04

Lo que recibe es una cabecera simplemente diciéndole, no, no, yo no te voy a dar la respuesta, tienes que buscarla en este otro sitio. ¿Y cuál es ese otro sitio? Pues vamos a ver ahora. Bueno, dejamos correr y vemos que el navegador inicia, este ya es Google, ¿vale? Esto ya es el servicio de Auth2 de Google. 01:06:05

Y me dice, selecciona la cuenta con la que quiero dar permisos a esta aplicación para que entre en mis tareas. Y yo, pues, esta misma. Vale, como estoy, me dice, te han dado acceso a una aplicación que aún se está probando. 01:06:33

acordaros que también os dije estas aplicaciones de momento google cuando las registras las pone 01:06:55

como en prueba no son aplicaciones de las que te dan todas las garantías porque tampoco hemos 01:07:00

pasado por ningún mecanismo de verificación de esta aplicación que siempre te avisa puede ser 01:07:07

que tú puedas añadir estos usuarios como usuarios de prueba y a lo mejor posiblemente de esa manera 01:07:13

no te avise cuando registras la aplicación puede estar de alta unos usuarios de prueba en este caso 01:07:19

yo no registré ninguno y sí que me sale este mensajito este este aviso diciendo cuidado que 01:07:25

esta aplicación está un poquito de esa manera vale yo le digo continuar y ahora ya si me da 01:07:31

vale me dice confirma ya tengo cierto acceso de ejecuciones previas vale pero tengo que de alguna 01:07:38

Y el servicio al que he dado permiso es este, ¿no? 01:07:49

Crear, modificar, organizar y eliminar tareas. 01:07:51

Luego lo veremos. 01:07:58

Desde tu cuenta de Google tienes acceso, a ver si me da acceso desde aquí. 01:07:59

Desde mi cuenta de Google, como veis, aquí tengo todas las aplicaciones que me han pedido permisos. 01:08:04

Y si lo comprobáis vosotros en vuestras cuentas de Google podéis ver a quién habéis dado permiso. 01:08:14

Yo doy permiso a Mailbird porque es un cliente de correo y Screencastify porque es una aplicación para hacer lecturas de pantallas, etc. Esta es mi aplicación, esta de repartos es la que hemos construido y obviamente le estoy dando permiso y esta es la de Playground, que también ha requerido mi permiso para acceder a mis tareas y yo se lo he dado para poder continuar con la demo. 01:08:20

Y vosotros aquí podéis ver listadas todas las aplicaciones que en un momento dado, que a lo mejor no sois ni conscientes, tienen permiso a vuestros datos, ¿vale? Mailver, pues aquí posiblemente, estos son todos los permisos que tiene, leer, redactar, enviar, eliminar, correos, a menos, bueno, decidido que yo quiero tener un cliente de correo, pues estos son los permisos que yo le he dado, ¿no? 01:08:46

de gmail a esta aplicación calendarios contactos con estas aplicaciones es tema profesional pues 01:09:12

no pasa nada profesionales tampoco pero si son personales cuidado con todo esto porque todas 01:09:23

estas aplicaciones pueden ir a vale y lo mismo con las otras aplicaciones vale podéis revisar 01:09:29

un poco qué tipo de permiso les habéis dado a cada una de ellas vale yo estaba estaba aquí 01:09:38

vale hecho le digo venga pues continuar confirmó que confío en esta aplicación cuando voy a 01:09:47

continuar es que se me vuelve otra vez activar el script index porque porque google ha redireccionado 01:09:55

de nuevo el navegador para que acceda a la uri extra de redirección que es http 2 punto barra 01:10:05

barra localhost 2.8 mil es decir activa mi índex de nuevo y ahora sí que tengo en dólares como 01:10:12

veis y que tengo datos en dólares y que tengo datos porque de hecho bueno sí que tengo me ha 01:10:19

llegado esa petición con esos datos si yo vuelvo a ejecutar el script vuelvo a creer el google 01:10:32

client con los mismos datos llegó a este if pero este if ahora sí que retorna verdadero el y set 01:10:42

de get the code me dice si lo puedo evaluar true vale así que entra por esta rama porque sí que me 01:10:51

llega en este mensaje url yo he dado el permiso me llega el código que hago con este código vale 01:11:05

por lo primero es cambiarlo por un token de acceso y un método también de la librería que se llama 01:11:12

fetch access token with of code yo le pasó el código es este de aquí y me lo va a convertir me 01:11:19

lo va a transformar en un access token que es lo que nosotros hacíamos con el playground vale 01:11:28

Acordaros aquí, ¿no? Aquí hacía un intercambio, ¿no? Este era off-code y yo voy a recibir, voy a intercambiarlo por un token de acceso. Vale, pues ejecuto esto, ¿vale? Aquí tengo el token. Y el token, pues tiene mucha información. Tiene información del token como tal, pero también tiene información de cuando aspira, me da un token de refresco, de qué scope es el que tiene permitido, una serie de datos. 01:11:34

y yo que hago con ese token, lo guardo 01:12:04

en la sesión, vale, este token 01:12:06

que he recibido aquí 01:12:08

que he obtenido, habiendo 01:12:10

ejecutado este método, lo que hago es lo meto 01:12:12

en el campo 01:12:14

token de la sesión 01:12:16

que tengo en PHP 01:12:18

que también expira en su momento, o sea con esto 01:12:20

tampoco te salvas, porque llega un momento 01:12:22

en que estos tokens también 01:12:24

dentro de la sesión, esta información expira 01:12:26

y no quedaría otra que 01:12:28

volver a refrescar y volver otra vez a 01:12:30

a molestar al usuario para que te diera permiso de nuevo para entrar aquí tampoco es una si tú 01:12:32

no quieres molestar al usuario una vez que te ha dado el permiso ya funcionar con ese toque 01:12:40

tendrías que guardar este toque en otro sitio y hacer cierta gestión de ir refrescando los 01:12:44

tokens vale guardo también el refresh toque por si lo necesito que en este caso no en principio 01:12:48

no bueno sí sí que utiliza pues si está aspirado lo intentó refrescar vale y ahora en esta en este 01:12:56

en este escenario sí que ya voy a entrar también por aquí porque hice sesión de toquen sí sí sí 01:13:05

ahora sí ahora esto es true porque lo acabo de meter aquí arriba estoy en una sesión en la que 01:13:12

ya tengo el código y lo tengo metido en la sesión que hago bueno pues establezco en el cliente 01:13:20

establezco ahora el token de sesión vale set access token es decir le doy de alta el token 01:13:29

de acceso dentro del objeto este de cliente que me representa un poco el google client 01:13:36

pregunto está expirado puede que haya expirado ya lo tenga pero a efectos de google dice no 01:13:43

no esté este token y aspirado no puedes usarlo entonces tendría que entrar en el proceso de 01:13:51

refrescarlo vale pasándole el refresh token con este otro método fech access token with 01:13:56

refresh toque en este caso no debería estar inspirado con lo cual si no está 01:14:02

si no está expirado salta este if 01:14:11

y directamente me viene aquí, ¿vale? 01:14:14

Salto este if y directamente 01:14:18

vengo aquí. 01:14:20

¿Vale? 01:14:25

Una vez que estoy en este punto 01:14:26

yo ya puedo 01:14:29

solicitar 01:14:31

la posibilidad de hacer 01:14:32

o de usar el API 01:14:34

de Google Tasks. ¿Vale? 01:14:36

Porque hasta aquí todavía 01:14:38

lo que he hecho es este proceso de aquí arriba. 01:14:40

Esto de aquí arriba. 01:14:43

pero todavía no enviado ningún mensaje para solicitar información de tareas este punto 01:14:44

3 todavía no lo he hecho hecho este primero y hecho este segundo y me encuentro con que ya 01:14:50

tengo estos tokens y estoy preparado para enviar mensajes http con el formato correcto para poder 01:14:56

solicitar información de tareas vale y entonces este objeto esta clase google service tasks es 01:15:06

parte de lo que me descarga el cliente de google para interaccionar con el api de google estás vale 01:15:15

si tuviera que interaccionar interaccionar con otro servicio con gmail o con youtube pues que 01:15:25

tendría que crear otro objeto tendría que crear new google service youtube vale pero fijaros que 01:15:30

le pasó el objeto cliente donde está el toque en donde está hay un montón de información para que 01:15:37

con esa información y mis peticiones él compruebe pues sí pues tiene el toque de autorización todo 01:15:42

es correcto la información de las tareas de juan vale pues y hasta aquí y hasta aquí hasta aquí la 01:15:48

parte del cliente google que os quería mostrar antes de empezar ya con el código concreto de 01:16:01

la aplicación porque os lo quiero mostrar desde más alto nivel no entrar en código tan bajo nivel 01:16:06

de alguna manera asegurarme de que todo este proceso se ha quedado más o menos claro 01:16:13

y que lo tenéis entendido bien pues voy a enseñaros por encima el api de google task 01:16:22

y ya arranco directamente 01:16:39

con la aplicación de reportes 01:16:41

por ejemplo, tenéis estos dos enlaces 01:16:47

y os llevan 01:17:01

a una descripción 01:17:03

genérica 01:17:06

aquí tenéis las operaciones 01:17:06

que podéis hacer sobre 01:17:10

las listas de tareas 01:17:11

aquí tenéis en principio 01:17:12

como digo 01:17:15

vosotros no vais a utilizar las urls 01:17:17

Sino que vais a utilizar la librería PHP 01:17:19

Que os va a simplificar todo esto 01:17:22

Vamos a entrar luego en el código de la librería 01:17:24

Para que veáis un poquito 01:17:26

Las operaciones que tenéis disponibles 01:17:27

Pero esto es un poco conceptualmente 01:17:29

Aquí os muestra 01:17:31

Cuál va a ser un poco la URL 01:17:32

Donde tenéis que poner los parámetros 01:17:36

Y os da un poquito 01:17:38

Una descripción textual 01:17:39

De qué operaciones tenéis 01:17:41

Entonces tenéis delete, get, insert, list, patch, update 01:17:42

Y luego sobre la tarea 01:17:45

Que aquí dice del equipo 01:17:47

puedan asignar tareas. Esto no lo entiendo muy bien. 01:17:49

Esto está mal traducido. En realidad esto es 01:17:51

listas de tareas y esto es tareas, 01:17:53

operaciones que podéis hacer sobre tareas 01:17:55

concretas. Podéis borrar, 01:17:57

podéis obtener, podéis insertar, 01:17:59

podéis listar, podéis mover 01:18:01

el orden, podéis 01:18:03

modificar cosas, 01:18:05

podéis hacer distintas cosas 01:18:07

con una tarea concreta. 01:18:08

¿Cómo vamos 01:18:12

a utilizar nosotros estas operaciones? 01:18:13

Pues, 01:18:16

os adelanto. Recordad que 01:18:17

en su momento 01:18:18

nosotros en nuestro diseño orientado a objetos 01:18:19

en nuestra aplicación vamos a tener 01:18:22

objetos listas de tareas y objetos 01:18:24

tareas y objetos 01:18:26

producto del que teníamos de toda la vida 01:18:28

que hemos ido utilizando 01:18:30

las distintas aplicaciones 01:18:32

y en su día 01:18:33

programamos DAOs 01:18:36

programamos objetos DAO 01:18:40

que permitían que esos 01:18:41

objetos que íbamos creando pudieran 01:18:44

ser persistidos, pudieran ser 01:18:46

guardados, almacenados 01:18:48

en ese medio persistente 01:18:49

cuando creamos un nuevo producto 01:18:51

pues lo podíamos meter en la base de datos 01:18:54

bueno, pues ahora ese medio persistente 01:18:55

ya no va a ser una base de datos 01:18:57

MySQL que tengamos asociada al script 01:18:59

sino que va a ser el servicio 01:19:02

de tasks 01:19:03

¿sí? se coge un poquito la idea, entonces 01:19:04

yo en vez de cuando vaya 01:19:07

a utilizar el API o la aplicación 01:19:09

perdón, cuando voy a utilizar la aplicación 01:19:12

voy a tener un pequeño formulario 01:19:13

que me va a permitir 01:19:15

guardar un reparto 01:19:16

¿vale? ese reparto 01:19:19

estamos hablando de logística ¿vale? estamos hablando 01:19:21

de que tengo que llevar una impresora 01:19:23

a tal sitio de Madrid ¿vale? esos son repartos 01:19:25

es una empresa de logística 01:19:28

entonces 01:19:29

esos repartos 01:19:31

¿dónde se van a guardar? se tienen que guardar porque una vez 01:19:32

que lo he creado, si no lo guardo 01:19:35

desaparece ¿no? una vez que la script 01:19:38

termina, toda esa información que tengo 01:19:39

en memoria desaparecería, tengo que guardarlo 01:19:41

en algún sitio, bueno pues ¿dónde lo voy a guardar? 01:19:44

en mi agenda de Google Tasks. 01:19:46

Voy a codificar esa información para que aparezca de alguna manera 01:19:50

toda representada, porque la tarea tiene pocos campos, 01:19:53

pero ya la voy a codificar de una manera que pueda meter la dirección, 01:19:59

pueda meter datos de las coordenadas, 01:20:02

puede meter información distinta que voy a requerir, 01:20:04

y la voy a guardar en mis tareas. 01:20:09

Entonces, una task list. 01:20:12

Y ahora viene un poco la explicación de por qué esto está básico. Una task list representa los repartos de un día. Como veis, repartos del 22 del 4 del 2022 o del 29 del 4 del 2024. 01:20:13

o sea que una lista de tareas me va a permitir representar los repartos de un día 01:20:27

si yo abro uno de ellos, aquí están los repartos individuales 01:20:39

vale, entonces, ¿dentro de qué información quiero representar para un reparto? 01:20:46

Pues el producto que quiero repartir, un monitor, LCDTDT, reconocéis posiblemente el nombre del producto porque está sacado de la base de datos del producto, ¿vale? Porque vamos a interaccionar también solicitando esa información a la base de datos del producto. 01:20:52

luego tengo una persona que lo separa de la calle de la información de la dirección a la que tengo 01:21:09

que llevarlo esto sería el título vale pero como veis lo tengo codificado con un aquí en el medio 01:21:18

para que luego cuando lo lea pueda sacar por un lado el nombre y por otro lado la dirección y 01:21:25

luego aquí hay una nota asociada que es la información de coordenadas geográficas la 01:21:31

latitud pero en la longitud y la latitud vale también separado con un ant vale voy a leer esto 01:21:38

voy a tener que partir ese script pero en ese string en dos trocitos con un separador que se 01:21:48

la voy a los dos datos en cada lado delante y uno va a ser un dato de coordenada y otro 01:21:54

otro vale es un poco para que os voy a enseñar la aplicación funcionando y luego la vemos un 01:22:00

poco a nivel de diseño vale entonces vale vamos a verlos esto estaba vamos a cortar es así 01:22:10

vale continuar vale está iniciando la sesión y este es el interfaz no es demasiado fancy 01:22:32

demasiado vistoso pero bueno suficiente es un interfaz orientado a tabla muy tabular 01:22:42

entonces por ejemplo que puedo hacer desde este interfaz puedo crear una lista de reparto es 01:22:47

decir puede decir bueno pues voy a iniciar el reparto del día 8 sí y creo una nueva lista de 01:22:56

reparto. ¿Vale? 01:23:02

¿Cómo que vale? 01:23:13

A ver. 01:23:16

Estaba tocando cosas. 01:23:19

¿Qué pasa? 01:23:21

¿Por qué no funciona? 01:23:22

Dame un segundito. 01:23:24

Voy a cerrar 01:23:27

todo esto que pueda tener por aquí. 01:23:30

Voy a cerrar 01:23:36

cualquier aplicación que tenga por aquí. 01:23:39

A ver si se ha quedado en algún... 01:23:41

y este tiene algo corriendo 01:23:45

vale 01:23:50

está haciendo algún cambio, espero que no 01:23:57

cargando 01:24:00

vale, como veis, ya le he dado el permiso 01:24:04

ya tiene ese toque, ya puede 01:24:08

ya puede acceder directamente 01:24:10

vamos a ver si no me deja 01:24:14

cargar la lista 01:24:16

bueno, no sé 01:24:17

os lo muestro en la siguiente 01:24:26

algo he tocado 01:24:28

aparte de 01:24:28

Vamos a probar otras cosas, ¿vale? Vamos a probar, por ejemplo, que pueda borrar, vamos a añadir un nuevo reparto, ¿vale? A este día, al 30 del 4, vamos a añadir un nuevo reparto, ¿vale? 01:24:31

entonces digo dirección calle pues un paseo castellano así no estás 01:24:47

vale puedo ver las coordenadas vale acordaros de esto esto no lo hacía el servicio de mapas 01:24:56

de bing podría obtener a partir de una castilla de una dirección una sobre un poquito más vale 01:25:04

Aquí puedo tener información del producto, ¿vale? 01:25:17

Que quiero llevar y creo un nuevo envío, ¿vale? 01:25:22

Y aquí lo tengo, ¿vale? 01:25:28

Entonces, tengo este nuevo envío con estos datos. 01:25:29

Si lo vemos en Tasks, vemos que efectivamente, 01:25:33

¿dónde lo he añadido? 01:25:40

Lo he añadido en la lista de tareas del día 30, ¿vale? 01:25:41

Era este de aquí, Asia Castellana 245. 01:25:47

el día 30 01:25:50

¿vale? y aquí lo tenemos 01:25:52

como veis, está conectado y ya 01:25:53

los datos que yo voy creando 01:25:56

alguna los va depositando 01:25:58

en 01:26:00

en Google Tasks 01:26:01

voy a borrar una, para que veáis 01:26:04

también en la operación de borrado 01:26:06

que también desaparece 01:26:07

si queréis vamos a borrar 01:26:09

pues en el mismo día 30 01:26:11

vamos a borrar la otra que teníamos 01:26:14

voy a borrar, confirmarlo 01:26:15

la borra en Google Tasks 01:26:19

y luego refresca 01:26:22

de nuevo el listado que me muestra 01:26:24

ahora ya sin esa 01:26:27

esa tarea, vale 01:26:28

aquí ya ha desaparecido, con lo cual 01:26:30

esa conexión 01:26:32

entre 01:26:33

¿qué más cosas hace la aplicación? 01:26:35

podemos encontrar 01:26:43

los mapas, vale, entonces digo 01:26:44

pues paseo castellana 245 01:26:46

enséñame el mapa 01:26:48

y te muestra aquí el mapa 01:26:49

esto también lo hacemos con un API REST 01:26:51

en principio 01:26:54

este API por ejemplo es distinto 01:26:56

porque este API lo estamos utilizando 01:26:58

directamente desde el cliente 01:26:59

no lo utilizamos a través del servidor 01:27:01

por ejemplo el de las coordenadas 01:27:04

sí que lo utilizamos a través del servidor 01:27:05

yo le envío la petición al servidor 01:27:07

al script.hp, él se pone en contacto 01:27:09

con el API de Microsoft 01:27:12

recibe la información 01:27:14

y la pasa 01:27:15

al cliente, o sea que es el servidor 01:27:18

un poco el que tiene la comunicación con el API REST 01:27:20

eso sin embargo no, los mapas 01:27:22

directamente desde el cliente Javascript 01:27:24

se ejecuta un Javascript que permite cargar 01:27:26

este pequeño mapa 01:27:28

dentro de la página 01:27:30

que está cargada en ese momento 01:27:32

vale 01:27:34

volvemos 01:27:35

ya hemos hecho, ya hemos añadido cosas 01:27:39

ya hemos borrado, vamos a 01:27:42

hay una cosa interesante que es la de ordenar 01:27:44

vale, entonces 01:27:46

la de ordenar, lo que hace es 01:27:48

poner de alguna manera, hacer un recorrido 01:27:49

óptimo, que también 01:27:52

es una funcionalidad del API de Microsoft 01:27:54

poner un recorrido 01:27:55

óptimo para hacer 01:27:58

un poco 01:27:59

la entrega 01:28:00

la persona que conduce la furgoneta 01:28:03

pues que sepa que ruta 01:28:07

es la más adecuada dependiendo 01:28:09

de donde están situados 01:28:12

los destinos de los envíos 01:28:12

entonces, vamos a hacer 01:28:15

una cosa, vamos a entrar aquí, vamos a 01:28:17

cambiarlo, a ver si 01:28:19

aquí el día 29 01:28:20

vale 01:28:23

no sé si puedo, podría 01:28:25

cambiar esto, moverlo 01:28:28

vale, voy a moverlo un poquito, vale, para 01:28:29

cambiarlo de orden 01:28:31

vale, lo he cambiado 01:28:33

de orden, con lo cual si yo refresco 01:28:35

la aplicación 01:28:38

pues que tenemos el 01:28:41

Nintendo Epson al final 01:28:43

y Nintendo al principio 01:28:45

vale, donde estaba 01:28:49

vale, estos han cambiado 01:28:52

de alguna manera 01:28:57

y Epson voy a ponerlo al primero 01:28:58

para que se vea más claro el cambio 01:29:00

vale 01:29:03

voy a volver otra vez a cargar 01:29:08

el navegador 01:29:10

voy a refrescar esto, vale, para que me dé 01:29:11

ahora Epson lo va a poner al primero 01:29:14

vale, lo ha cambiado 01:29:16

y ha sido fiel, digamos, al orden 01:29:20

en el que estaba en las tareas de Google Tasks 01:29:22

si yo le pido que lo ordene 01:29:26

ahora de alguna manera va a buscar la ruta óptima 01:29:27

vale, me dice que está ordenada 01:29:32

y como veis ha cambiado el orden 01:29:35

en el que sitúa los productos 01:29:37

en la tabla, ¿por qué? 01:29:41

pues porque en el mapa de la ruta 01:29:43

ha ido colocando los distintos productos 01:29:45

en el orden que piensa que es más óptimo 01:29:52

para hacer un poco la ruta final 01:29:54

este es el punto de partida, que es un punto configurable 01:29:56

Dentro de la configuración de entorno, tú puedes decirle cuál es la latitud y longitud del punto de partida donde está tu almacén y luego directamente, pues, con los elementos que tú le has dado, pues, va de alguna manera conectándolos, haciendo la ruta, pues, imagino que dependiendo del tráfico, dependiendo de... 01:30:00

Todo esto, como digo, lo hace Microsoft, ¿vale? 01:30:18

Él sabe un poco cuál es la ruta óptima en coche para hacer eso. 01:30:22

Y aquí te los ordena. 01:30:25

También te ordena estos elementos para que los vayas viendo en el orden que se van a entregar. 01:30:28

Vale, vamos a borrar una, a ver si esto funciona, una lista de repartos del día 30. 01:30:35

esto sí funciona, no sé por qué 01:30:49

tengo que mirar lo de la lista de reparto 01:30:52

a ver por qué falla 01:30:54

vale, pues esta es la aplicación 01:30:55

un poco para que 01:31:01

veáis un poco 01:31:02

la magnitud y todo 01:31:04

lo que conlleva 01:31:07

hay que gestionar esos APIs REST, hay que gestionar 01:31:08

los APIs también de coordenada 01:31:11

la base de datos de productos 01:31:13

aunque no vayamos a tocar nada en productos 01:31:14

o sea no vamos a insertar nada ni a modificar 01:31:17

nada, pero sí que vamos a extraer información 01:31:19

porque cuando queremos 01:31:21

añadir un reparto 01:31:23

nuevo 01:31:25

obviamente hay que rellenar este 01:31:25

este menú 01:31:29

contextual y todos estos nombres 01:31:31

salen de los nombres de la base de datos 01:31:33

vale 01:31:35

entonces 01:31:37

os voy a 01:31:38

os voy a 01:31:41

iniciar, no me va a dar mucho más tiempo 01:31:43

para entrar en el código, quizás 01:31:45

la semana que viene lo vemos más en el código 01:31:47

hoy voy a trabajar un poquito más 01:31:49

como os decía, en la parte más de diseño 01:31:51

¿vale? y el próximo día 01:31:53

entramos un poquito más 01:31:55

en el código real 01:31:57

entonces 01:31:59

de todas maneras 01:32:00

quizás pueda adelantar 01:32:02

esta presentación para que la tengáis 01:32:05

vosotros ya 01:32:07

disponible 01:32:08

¿vale? para si queréis empezar a codificar 01:32:11

o a entender código os va a facilitar 01:32:13

el trabajo 01:32:15

entonces vamos a ver un poco el diseño de la misma manera 01:32:15

que os he ido presentando 01:32:19

los diseños de otras aplicaciones 01:32:21

que es primero 01:32:22

teniendo claro cuáles van a ser las 01:32:24

ventanas con las que voy a interaccionar 01:32:26

y aquí esta es 01:32:29

posiblemente la ventana más importante 01:32:31

donde hay más botones, donde hay más cosas que tengo que interaccionar 01:32:32

tanto para crear una lista de reparto 01:32:35

como para crear nuevos repartos 01:32:37

borrarlos 01:32:39

pedir información de 01:32:40

mapa de cada uno de ellos 01:32:42

donde están situados 01:32:44

un mapa de la ruta 01:32:45

de todo el reparto 01:32:47

de todos los envíos de ese día 01:32:50

bueno pues 01:32:52

esta ventana tiene bastante funcionalidad 01:32:54

luego tengo este formulario 01:32:57

que es el formulario para crear un reparto 01:32:58

con una dirección 01:33:01

la que tengo que 01:33:02

completarla con las coordenadas 01:33:03

de la dirección, el usuario 01:33:07

el tío de la docencia solo metería la dirección 01:33:08

y en principio el producto 01:33:11

¿vale? no metemos 01:33:13

de más información, esto es un poquito 01:33:14

de juguete, pero bueno, por lo menos el producto 01:33:17

que tenemos que repartir. 01:33:19

Y las coordenadas, tenemos 01:33:21

la altitud, longitud y altitud, 01:33:23

que esta finalmente no se usa, obviamente, para 01:33:24

saber dónde está el tema, pero bueno, 01:33:26

la utilizamos también como ejercicio 01:33:29

de recuperación de 01:33:31

información geográfica. 01:33:32

¿Vale? Tenemos los mapas 01:33:35

que solamente tienen este botón de volver. 01:33:37

Tanto el mapa de situación 01:33:39

de un reparto como el 01:33:40

de la ruta completa. Bueno, solo tiene 01:33:43

este botón. 01:33:45

Vale, pues una vez que tenemos ya claro cuáles son las pantallas de mi aplicación, yo puedo empezar a pensar un poco más en la aplicación como tal. Y posiblemente lo que os interesa es pensar, para empezar, en este tipo de diagrama. 01:33:45

Un diagrama de arquitectura. Es un diagrama en el que tenéis que empezar a tomar decisiones de cómo vais a llevar a cabo, cómo vais a implementar la funcionalidad, qué elementos necesitáis y qué elementos vais a tener a vuestra disposición. 01:34:03

cada uno va a necesitar 01:34:20

una parte de implementación 01:34:22

entonces este es el cliente 01:34:24

y este es el servidor 01:34:26

aquí es donde vamos a tener nuestros scripts PHP 01:34:28

y aquí es donde se va a ejecutar 01:34:31

o ejecutar nuestros scripts Javascript 01:34:32

y vamos a tener por un lado 01:34:35

una comunicación estándar, por ejemplo 01:34:39

si enviamos un formulario 01:34:40

pues vamos a solicitar 01:34:42

que se haga cierta funcionalidad 01:34:44

dentro del servidor 01:34:47

que se ejecute en script y posiblemente 01:34:49

que se lance una VistaBlade, ¿vale? 01:34:50

Este es uno de los flujos que ya hemos visto. 01:34:53

Yo le pido una petición, hay un script de control, 01:34:56

recibe esa petición, la procesa y lanza una VistaBlade 01:35:00

que he tenido, obviamente, que he programado previamente. 01:35:05

Esa VistaBlade retorna y se carga en el navegador, ¿vale? 01:35:09

Uno de los flujos. 01:35:13

Otro de los flujos que va a haber dentro de esta aplicación 01:35:15

es IaaS, ¿vale? 01:35:17

O sea que no voy a recargar la página, sino que voy a solicitar directamente mediante AJAX una información, unos datos. Por ejemplo, el tema de las coordenadas. Pues a lo mejor el tema de las coordenadas lo puedo pedir por AJAX. 01:35:18

Aquí cuando pido coordenadas, en vez de volver otra vez a representar todo este formulario, a lo mejor este botón, como veis, tiene que funcionar por AJAX. 01:35:33

Y yo le envío la petición al servidor, el servidor hace la comunicación con su servicio REST, se hace con las coordenadas y me las envía en un ficherito a Json. 01:35:43

Y yo directamente, pim, pim, pim, las coloco aquí. 01:35:52

¿Vale? 01:35:56

Puede ser un uso sin falta de tener que volver a recargar el formulario completo. 01:35:57

puede ser un uso interesante de IAX 01:36:01

así que va a haber ciertas comunicaciones 01:36:03

entonces tengo que empezar a pensar un poco 01:36:05

qué comunicaciones quiero hacer mediante el flujo 01:36:07

estándar y qué comunicaciones 01:36:09

pues puede ser interesante que haga mediante 01:36:11

IAX 01:36:13

dentro del servidor yo obviamente 01:36:13

voy a tener que por un lado 01:36:17

establecer comunicación con la base de datos 01:36:18

de proyecto utilizando PDO 01:36:21

o sea que voy a tener un DAO 01:36:22

para productos 01:36:24

un producto DAO 01:36:27

No va a tener implementado ningún método de insertar, ni modificar, ni borrar, pero sí a lo mejor alguno de obtener, ¿no? Obtener productos, porque los necesito, los nombres al menos, para poder rellenar este formulario, ¿vale? Todos los productos aquí, este menú desplegable. 01:36:28

voy a tener esta parte de pd voy a también interacción interaccionar con con mapas vale 01:36:45

esto para que esto es para la parte de obtener las coordenadas esto es la parte de obtener las 01:36:54

coordenadas no los voy a obtener yo con mi código voy a interaccionar con bing map rest services 01:37:01

vale tengo que tener mi cuenta que voy a tener registrada mi clave etcétera etcétera para hacer 01:37:07

lo que hicimos en la primera tutorial 01:37:12

¿verdad? en la primera tutorial hicimos ya 01:37:14

esto de dar una dirección 01:37:16

y él directamente me da la información 01:37:18

de coordenadas 01:37:20

pero también voy a interaccionar 01:37:22

con Google Tasks 01:37:24

¿vale? y este es otro 01:37:25

API de otro proveedor, en este caso 01:37:28

Google, obviamente 01:37:30

previo, este es un servicio que requiere 01:37:32

este tipo de autorización previa con 01:37:34

auth 2.0 01:37:36

¿vale? o sea que voy a interaccionar 01:37:37

con Google, primero 01:37:40

en con su servidor de off que es justo el código que os enseñe hace un momentito pero también 01:37:42

utilizando el toque de acceso voy a utilizar el api de taxis todo esto en comunicación con 01:37:49

google vale y desde el cliente aparte de aquí de ejecutar javascript que voy a tener que programar 01:37:56

también cierto javascript para ciertas funcionalidades ya veréis el programa y 01:38:02

y veréis un poco lo fácil y lo 01:38:08

flexible y lo interesante 01:38:10

que puede ser jQuery 01:38:12

si es que no utilizáis un framework de cliente 01:38:13

y desde aquí también voy 01:38:16

a interaccionar, desde el cliente voy a 01:38:18

interaccionar con Microsoft 01:38:20

Maps, ¿vale? ¿Para qué? Pues para 01:38:21

construir estos mapas de aquí 01:38:24

estos mapas de aquí 01:38:25

directamente 01:38:27

desde la aplicación 01:38:29

JavaScript 01:38:31

¿vale? Y esto ya os empieza 01:38:32

a dar una idea de cómo se 01:38:36

programan sin frameworks 01:38:38

que obviamente 01:38:40

no es la manera 01:38:42

siempre se va a programar con frameworks, pero podéis intuir 01:38:43

cómo 01:38:46

se pone de alguna manera 01:38:48

todo el conjunto de lo que es una aplicación web 01:38:50

aquí ya veis 01:38:52

desde el cliente, javascript 01:38:53

vocación a APIs desde el mismo cliente 01:38:55

código que se ejecuta en el servidor 01:38:58

una base de datos de la que se 01:39:00

recuperan informaciones, consultas 01:39:02

a servicios externos 01:39:04

utilización de AJAX 01:39:06

en ciertas de las peticiones 01:39:07

en las que no conviene recargar toda la página 01:39:10

bueno, ahora 01:39:12

esto un poco también para que veáis un poco 01:39:14

la imagen completa 01:39:17

de lo que puede ser una aplicación 01:39:19

semi-real 01:39:20

como digo, todavía no 01:39:22

yo creo que no se lo puede considerar real del todo 01:39:24

pero sí que ya podéis un poco vislumbrar 01:39:27

que aquí pues tendremos 01:39:29

un framework PHP 01:39:30

como Laravel o como Zend 01:39:32

Aquí tendremos un framework de cliente como Angular y empezamos un poco a vislumbrar cómo podemos construir una aplicación web ya profesional o ya en el ámbito real, ¿no? Finalmente, ¿no? Con todo lo que hemos ido o habéis ido trabajando con los módulos del curso, finalmente llegáis a tener quizás esa visión completa y este ejercicio os da un poco la posibilidad de ponerlo todo junto. 01:39:34

Vale. Tenemos un diseño orientado a objetos, ¿sí? Obviamente, las aplicaciones siempre van a trabajar con ese diseño. Los objetos nos van a ir bien porque va a ser con lo que van a interaccionar los scripts de control. 01:40:05

Los clientes de control van a trabajar con objetos de lista de reparto, van a trabajar con objetos de reparto y cada reparto va a estar linkado de alguna manera a un producto, ¿vale? Que es el producto que reparte, ¿sí? Cada uno tiene sus propiedades, ¿sí? Este es el diagrama de clases. 01:40:20

que conviene también tener claro un poco 01:40:38

por eso esta documentación 01:40:40

siempre que podáis 01:40:42

establecer un poquito estos diagramas básicos 01:40:44

con qué vais a estar trabajando 01:40:47

y qué tipo de información 01:40:49

vais a representar como objetos 01:40:51

conviene un poco que la 01:40:53

que la tengáis 01:40:55

más o menos clara 01:40:56

y en cuanto a los scripts de control 01:40:57

vamos a trabajar con un único script de control 01:41:00

esto quizá os llame la atención 01:41:03

podríamos haberlo separado en varios 01:41:05

porque sí que hay varios tipos de funcionalidad 01:41:06

pero ya veréis como con un único 01:41:09

script de control, un index 01:41:11

bueno, largo pero bien estructurado 01:41:12

tampoco va a ser muy complicado 01:41:15

de seguir porque 01:41:17

cada proceso de cada operación nos va a llevar 01:41:18

muy poco código, ¿por qué? porque siempre va a 01:41:21

delegar, desde el script de control rápidamente 01:41:23

se delega la funcionalidad en objetos 01:41:25

que se han creado 01:41:27

no se pone el script de control a hacer 01:41:28

cosas demasiado complejas, a desarrollar 01:41:31

lógicas complejas, no, crea un objeto 01:41:33

y le pasa la funcionalidad. 01:41:35

Le devuelve el resultado del objeto 01:41:38

y con eso continúa con el proceso de la solicitud. 01:41:39

Y ya veréis cómo, a lo mejor son 6, 7 líneas 01:41:43

de código en cada una de las peticiones 01:41:46

que le pueden llegar a index. 01:41:49

Pero vamos a tener un único index. 01:41:50

Y por lo demás, vamos a tener 01:41:52

varios ficheritos Javascript 01:41:54

que me van a hacer ciertas de las operativas 01:41:56

y de las funcionalidades requeridas. 01:41:59

Y por otro lado, vamos a tener 01:42:02

conexión a la base de datos, 01:42:03

vamos a hacer unos DAOs 01:42:04

por DAOs 01:42:05

parte del producto DAO 01:42:07

el producto DAO 01:42:08

ataca a la base de datos 01:42:09

MySQL 01:42:11

pero estos dos DAOs 01:42:11

atacan 01:42:12

al servicio REST 01:42:14

de Google Tasks 01:42:16

bueno, así que cuando 01:42:17

queramos 01:42:19

dar persistencia 01:42:20

a una tarea 01:42:22

obviamente 01:42:23

le vamos a pasar 01:42:24

esa tarea 01:42:25

a este 01:42:26

perdón 01:42:27

un reparto 01:42:28

le vamos a dar ese reparto 01:42:29

a este DAO 01:42:30

para que lo cree 01:42:31

pero no 01:42:32

ese código de crear 01:42:33

no va a tener PDO, sino que va a tener 01:42:36

llamadas a la API REST 01:42:38

de Google Tasks para que 01:42:40

se almacene 01:42:42

ese reparto en formato 01:42:43

tarea dentro del 01:42:46

servicio de Google Tasks. 01:42:48

Y luego una serie de vistas 01:42:52

que también vamos a tener. 01:42:53

Vamos a utilizar también 01:42:55

el formato estándar en el que 01:42:56

le escribe control. 01:42:58

También tira de vistas 01:43:01

Blade que se han escrito previamente. 01:43:03

para que le pasa parámetros para que finalmente se visualicen en en el navegador vale pues yo creo 01:43:05

que hasta aquí hasta aquí un poco os adelanto un poquito toda la operativa y la semana que viene 01:43:12

entramos ya en el código concreto por cada una de las peticiones vamos a ver qué parte se hace con 01:43:18

ayax qué parte requiere una persistencia con los dados qué parte y vamos a ir revisando el código 01:43:26

de cada una 01:43:34

de las partes de la aplicación 01:43:36

para ver cómo realmente la operación 01:43:38

se lleva a cabo. Vale, pues 01:43:40

venga, ¿preguntas finales? 01:43:44

No, muchas gracias 01:43:48

por la clase. No, pues 01:43:50

venga, pues a vosotros. Yo solo 01:43:51

quería preguntar lo del doten. 01:43:53

Eso es para lo de las variables 01:43:56

de entorno, ¿no? Sí, justo. 01:43:57

El doten es un ficherito 01:44:00

que tienes... 01:44:01

Te viene un ejemplo, ¿vale? 01:44:03

Entonces, aquí tienes que 01:44:05

En vez de poner doten.ejemplo, le borras .ejemplo 01:44:07

y aquí le metes todos los datos tuyos concretos. 01:44:11

Vale, entonces, map api key es la clave que te haya dado Big Maps 01:44:15

cuando te ha registrado. 01:44:19

Lat base es la latitud en la que está tu almacén. 01:44:21

Busca una ubicación en Madrid, ¿vale? 01:44:26

Y con Google Maps consulta cuál es el dato de latitud. 01:44:29

Vale, será un numerito. 01:44:35

Vale. 01:44:37

Lo mismo con longitud, lo mismo con país, ciudad, localidad, para ver la base y luego tienes aquí los datos de la base de datos. ¿Y hay algún dato más? A ver, dame un segundito, ¿hay algún dato más? Espera, que te lo refresco. No te lo voy a poner en pantalla, ¿vale? Porque aquí yo tengo mis datos, pero te voy a poner algún dato más, es verdad. 01:44:37

Vale, te voy a poner estos datos, son, dame un segundito, y te lo pongo todo, veo que se ha quedado un poco obsoleto, aquí, vale, no, no, sí, no, es parecido, pensé que era más distinto, pero es parecido. 01:44:58

Tienes toda la parte de base de datos 01:45:34

Listo 01:45:52

Sería algo de este tipo 01:45:53

Aquí está utilizando por ejemplo 01:45:56

Root sin password 01:45:58

Pero sería algo de este tipo 01:46:00

Sería algo de este tipo 01:46:01

Vale 01:46:05

El DB host 127.0.1 01:46:07

la puerta 3306, el nombre de la base 01:46:09

de datos. Recuerda que accedemos 01:46:11

a la base de datos proyecto. 01:46:13

Route sin password. Esto no te va a dar 01:46:16

problemas de permisos. Luego tienes 01:46:17

Map API Key, que es lo que 01:46:20

efectivamente 01:46:21

te dé 01:46:22

la web de Microsoft. 01:46:24

Tienes la latitud, 01:46:28

la longitud, el país, la ciudad, la localidad 01:46:30

donde está tu almacén. 01:46:32

Para que luego, cuando 01:46:35

quiera elaborar la ruta, sepa de dónde tiene 01:46:36

que salir el camión. 01:46:38

Y el único que te queda que tienes que rellenar es este de aquí, que es donde están tus credenciales de Google, ¿vale? Entonces, este es el ficherito, el ficherito que te has descargado, el ficherito Json que te has descargado de Google, ¿eh? Cuando has hecho el registro de la aplicación, puede ser algo así, por ejemplo. 01:46:39

vale 01:47:09

y ese sería el nombre del fichero 01:47:11

en el que te has descargado 01:47:13

los credenciales 01:47:16

vale 01:47:17

con estos datos de configuración ya debería 01:47:19

de funcionar 01:47:22

la aplicación, vale, si los tienes correctos 01:47:23

vale 01:47:26

muchas gracias Iván 01:47:27

vale, venga Luis 01:47:29

ya la otra semana es la última tutoría, verdad 01:47:31

no, va a haber alguna más 01:47:33

va a haber alguna más 01:47:35

La semana que viene voy a terminar ya con el código de la tarea 8 y ya en principio terminaría, digamos, de presentar material, pero el resto yo estaré disponible ya sea para resolver a lo mejor ejercicios de los exámenes de otros años o para resolver dudas directamente. 01:47:36

Vale. 01:47:56

vale, o sea que 01:47:57

veré, si yo traigo material 01:47:59

y merece la pena lo grabaré, si no pues 01:48:02

básicamente me conectaré 01:48:03

y si la gente tiene dudas pues que se conecte 01:48:05

y os puedo echar una mano 01:48:07

en el proceso este de preparación 01:48:09

vale, muchas gracias 01:48:11

venga Luis, ánimo 01:48:14

hasta luego 01:48:15