Nueva versión de SDK Go para Latch

martes, 8 de agosto de 2017

Importante: esta versión de SDK Go no es oficial de Eleven Paths.


SDK Go para Latch
Latch tiene varios SDK implementados en varios lenguajes conocidos como Python o .NET. pero hasta ahora no había ninguno para el lenguaje Go, el cual cada vez está ganando más popularidad. Rafael Troncoso (@tuxotron de @cyberhadesblog) ha creado una primera versión de un SDK en este lenguaje creado por Google. Hemos estado realizando varias pruebas de los módulos básicos para comprobar que todo funciona perfectamente y así preparar una serie de artículos explicando su funcionamiento. Este será el primero de varios relacionados a la utilización de este SDK realizando diferentes operaciones sobre Latch.




El primer paso es obtener una cuenta de Latch ;) , directamente como desarrollador si no tienes ninguna, o puedes activar tu cuenta actual de usuario Latch como desarrollador (imagen superior). También será necesario instalar Go en la plataforma en el cual estemos trabajando Windows, Linux o Mac. Finalmente instalaremos la aplicación Latch para el teléfono móvil (puedes buscarla en la tienda de tu smartphone o desde la web)

Para instalar el SDK de Latch para Go tienes que ejecutar el siguiente comando desde la shell de tu plataforma:

# go get github.com/tuxotron//latch-sdk-go

Una vez ejecutado este comando, el SDK debería de estar instalado en la siguiente ruta:

$GOPATH/src/github.com/tuxotron/latch-sdk-go/

Prácticamente eso es todo lo que tienes que hacer para poder usar el SDK. Por lo que ya podemos comenzar a probar nuestra aplicación. 

Hay 2 valores que necesitaremos obtener desde la consola web de administración de Latch: Application ID y Secret. Estos valores pertenecen a la aplicación que hayamos creado. Desde el menú Manage Applications, seleccionamos el icono Edit de la aplicación que queremos proteger.


En este caso de ejemplo, los valores son: YkmAJAX2W4v4JU9jP3Ce y 7p9hrnmiWLf8EpbNcPFNfkaCrzPjW3kzTt2rrW9c, para Application ID y Secret respectivamente.

Vamos a realizar a continuación algunas pruebas básicas para testear la ejecución de código en Go realizando algunas llamadas a Latch básicas.

Crearemos un fichero de texto llamado main.go, por ejemplo, utilizando nuestro editor de texto favorito y escribimos el siguiente código:

package main
import (
"github.com/tuxotron/latch-sdk-go"
)
func main() {
const (
AppId  = "YkmAJAX2W4v4JU9jP3Ce"
Secret = "7p9hrnmiWLf8EpbNcPFNfkaCrzPjW3kzTt2rrW9c"
)
credentials := latch.Credentials{AppId, Secret}
application := latch.NewLatchApplication(credentials)
}

Este programa simplemente abrirá una instancia de nuestro servicio de Latch. Para poder asociar nuestra aplicación a Latch, desde la aplicación móvil tenemos añadir un nuevo servicio, si ya tenemos algún otro servicio pareado, o parear con Latch (Pair with Latch), si no tenemos ninguno pareado (recuerda que en Latch puedes crear varias aplicaciones al mismo tiempo).


Una hemos elegido la opción de parear, la aplicación móvil nos muestra un token de 6 dígitos.


De vuelta a nuestro código, vamos a añadir la llamada para realizar el pareo. El texto marcado en azul es el código que hemos añadido:

package main
import (
"fmt"
"github.com/tuxotron/latch-sdk-go"
)
func main() {
const (
AppId  = "YkmAJAX2W4v4JU9jP3Ce"
Secret = "7p9hrnmiWLf8EpbNcPFNfkaCrzPjW3kzTt2rrW9c"
)
credentials := latch.Credentials{AppId, Secret}
application := latch.NewLatchApplication(credentials)
res := application.PairWithToken("iMKUkV")

if res.Error.Code != 0 {
fmt.Println("Error Code:", res.Error.Code, ", Error Message:", res.Error.Message)
} else {
fmt.Println("OK")
fmt.Println(string(res.Data))
}
}

Este nuevo código realiza una  llamada a la función pair con el token recibido en la aplicación móvil:

res := application.PairWithToken("iMKUkV")

El resto del código simplemente imprime por pantalla el resultado de la llamada (no olvides el “fmt” en la sección de import). Si todo ha ido bien, cuando ejecutes tu código (go run main.go) recibirás el accountId. En nuestro caso este fue el resultado:

OK
{"accountId":"zZhqg7H9pabaZDDJg4y2HcFWCjZtDm6yXBg7QDdrKNjBJfreirxzjY74R2dtxbta"}

Ese accountId es lo que usaremos ahora para comprobar el estado de nuestra aplicación en Latch. Cómo ya hemos pareado nuestra aplicación, la llamada a la función de pareo (PairWithToken(...)) ya no la necesitaremos más , así que la vamos a comentar y vamos a añadir la llamada para comprobar el estado de nuestro Latch (status(...)). De nuevo el texto en azul refleja las modificaciones que hemos realizado:

package main
import (
"fmt"
"github.com/tuxotron/latch-sdk-go"
)
func main() {
const (
AppId  = "YkmAJAX2W4v4JU9jP3Ce"
Secret = "7p9hrnmiWLf8EpbNcPFNfkaCrzPjW3kzTt2rrW9c"
)
credentials := latch.Credentials{AppId, Secret}
application := latch.NewLatchApplication(credentials)
// res := application.PairWithToken("iMKUkV")
res := application.Status("zZhqg7H9pabaZDDJg4y2HcFWCjZtDm6yXBg7QDdrKNjBJfreirxzjY74R2dtxbta", false, false)

if res.Error.Code != 0 {
fmt.Println("Error Code:", res.Error.Code, ", Error Message:", res.Error.Message)
} else {
fmt.Println("OK")
fmt.Println(string(res.Data))
}
}

Hemos comentado la llamada a pair y hemos añadido la llamada a status. Esta función recibe tres parámetros. El primero de ellos es el accountId, el cual recibimos cuando hicimos el pareado y los otros dos son valores booleanos, que dictan como la aplicación móvil va a reaccionar (ver documentación Latch).

Si ejecutamos nuestro código ahora y no tenemos nuestra aplicación bloqueada con Latch, deberíamos ver por pantalla algo como:

OK
{"operations":{"WcqfYQErkANrk7wfijgv":{"status":"on"}}}

Como puedes recibimos dos valores, el ID de la operación y el estado. Latch te permite definir distintas operaciones dentro de una aplicación, por ejemplo, podríamos tener una operación que te permitiera hacer login y otra que te permita actualizar o crear registros, etc. En nuestro caso no tenemos definida ninguna operación por lo que Latch nos muestra la operación genérica para nuestra aplicación. El segundo valor que vemos es el estado de dicha operación. En este caso la operación está activa, no bloqueada.


Si ahora nos vamos a la aplicación móvil, bloqueamos nuestra aplicación y volvemos a ejecutar nuestro código, obtendremos algo como:

OK
{"operations":{"WcqfYQErkANrk7wfijgv":{"status":"off"}}}

Como podemos ver ahora el estado de nuestra operación está apagado o lo que es lo mismo la operación está bloqueada por Latch. Y además, como el tercer nuestros parámetros silent, lo hemos pasado con el valor falso, en la aplicación del móvil recibiremos una alerta:


Resumiendo, para proteger un servicio con Latch tendremos que realizar los siguientes pasos:

1. Obtener nuestro Applicaction ID y Secret
2. Petición de pareo, llamar a la función PairWithToken con el token obtenido en la aplicación móvil.
3. Guardar el accountId recibido en el pareo
4. Para proteger cierta operación, llamamos a la función Status con el accountId, y comprobamos si el estado (status) está a ON, entonces permitimos el uso de dicha operación, si el estado está a OFF, evitamos la ejecución de la operación y notificamos al usuario con el algún tipo de error.


Para terminar, si queremos desparear nuestra aplicación todo lo que necesitamos es llamar a la función Unpair, y le pasamos como parámetro el accountId:

package main
import (
"fmt"
"github.com/tuxotron/latch-sdk-go"
)
func main() {
const (
AppId  = "YkmAJAX2W4v4JU9jP3Ce"
Secret = "7p9hrnmiWLf8EpbNcPFNfkaCrzPjW3kzTt2rrW9c"
)
credentials := latch.Credentials{AppId, Secret}
application := latch.NewLatchApplication(credentials)
res := application.Unpair("zZhqg7H9pabaZDDJg4y2HcFWCjZtDm6yXBg7QDdrKNjBJfreirxzjY74R2dtxbta")
if res.Error.Code != 0 {
fmt.Println("Error Code:", res.Error.Code, ", Error Message:", res.Error.Message)
} else {
fmt.Println("OK")
fmt.Println(string(res.Data))
}
}

Y si todo ha ido bien, veremos impreso por pantalla un OK y también recibiremos una alerta en el móvil.




Estos son sólo los pasos básicos para comenzar a utilizar este SDK de Go. Vamos a seguir realizando pruebas que iremos publicando en este blog de ElevenPaths

Fran Ramírez
Investigador de ElevenPaths y escritor del libro “Microhistorias: anécdotas y curiosidades de la Informática” 


Rafael Troncoso
Co-fundador del blog CyberHades y escritor del libroMicrohistorias: anécdotas y curiosidades de la Informática” 



No hay comentarios:

Publicar un comentario