Seguimiento de ubicación de activos con NileDB - NileDB/com.niledb.core GitHub Wiki

Como puedes imaginar, NileDB (https://niledb.com) se puede utilizar en una amplia variedad de casos de uso de negocio distintos. Generar una capa de servicios GraphQL encima de un motor de base de datos PostgreSQL es un patrón muy potente.

Al final de este artículo serás capaz de seguir la localización en "tiempo real" de tus activos utilizando NileDB Core y la App para Android de NileDB.

¡Vamos!

Instalación de dependencias

Antes de nada, deberías tener Docker y Docker Compose instalados en tu máquina. Si no es así, puedes seguir las instrucciones de instalación en los siguientes enlaces:

https://docs.docker.com/install/ https://docs.docker.com/compose/install/

Instalación de NileDB Core

Una vez que tienes Docker Compose instalado en tu sistema, vamos a crear una instancia de NileDB Core siguiendo los siguientes pasos:

1. Crear una carpeta:

# mkdir tracking-your-assets
# cd tracking-your-assets

2. Añadir el siguiente contenido al fichero "docker-compose.yml":

version: "3.1"

services:
  db:
    container_name: db
    environment:
      POSTGRES_PASSWORD: postgres
    image: timescale/timescaledb-postgis:latest-pg10
    restart: always
    ports:
      - 5433:5432

  core:
    container_name: core
    depends_on:
      - db
    environment:
      - JAVA_OPTS="-Xms384m -Xmx384m"
    image: niledb/core
    links:
      - db
    ports:
      - 80:80
      - 1883:1883
    restart: always

3. Instalar NileDB Core:

# sudo docker-compose up

Este comando creará dos contenedores, uno para la base de datos PostgreSQL y otro para el servidor GraphQL de NileDB.

Crear la base de datos y regenerar los servicios GraphQL

4. Crear el esquema de datos:

Para poder almacenar los datos de localización de los activos, vamos a crear un esquema de datos:

En nuestro ejemplo, asumiremos que tenemos una empresa con varios agentes de mensajería repartiendo paquetes y queremos saber dónde están ubicados dichos agentes.

# sudo docker exec -it db psql -U postgres niledb

niledb=# CREATE TABLE "CarrierAgent" (
	"id" serial PRIMARY KEY,
	"firstName" text NOT NULL,
	"lastName" text NOT NULL
);

niledb=# CREATE TABLE "CarrierAgentLocation" (
	"id" serial PRIMARY KEY,
	"carrierAgent" int NOT NULL,
	"timestamp" timestamp NOT NULL DEFAULT now(),
	"location" point
);

niledb=# CREATE UNIQUE INDEX ON "CarrierAgentLocation"
	("carrierAgent", "timestamp");

niledb=# ALTER TABLE "CarrierAgentLocation" ADD CONSTRAINT "carrierAgent" 
	FOREIGN KEY ("carrierAgent") REFERENCES "CarrierAgent"("id");

5. Regenerar los servicios GraphQL:

A continuación vamos a generar la capa de servicios GraphQL para la base de datos que hemos creado. Navegamos a http://localhost/graphql con el navegador y ejecutamos el siguiente comando:

mutation {
  reloadGraphQLSchema
}

6. Crear un agente:

A continuación añadimos un agente con el siguiente comando:

mutation {
  CarrierAgentCreate(
    entity: {
      firstName: "Paco"
      lastName: "Hernández"
    }
  ) {
    id
  }
}

En el resultado podemos observar el identificador del agente que hemos creado. Este identificador lo uitlizaremos después para configurar la App de Android de seguimiento.

Instalar NileDB Tracker App para Android

7. Para poder instalar la aplicación desde GitHub, lo primero que haremos es habilitar "Unknown Sources".

En el apartado de configuración y seguridad, encontramos la opción de habilitar fuentes desconocidas. Tendremos que habilitarla para poder instalar la app desde el enlace de Github.

8. Descargar APK:

Puedes descargar el paquete de instalación de la App de Anddroid en el siguiente enlace: https://github.com/NileDB/com.niledb.tracker.android/releases/download/0.1.1/app-debug.apk

9. Instalar APK:

Ahora puedes abrir el paquete que has descargado e instalarlo en tu dispositivo Android.

10. Configurar NileDB Tracker para enviar la localización al servidor de NileDB:

La primera vez que abrimos la app, nos pedirá autorización para acceder a la localización. Tenemos que aceptar para que funcione correctamente nuestra app.

A continuación, configuraremos la app:

Empezaremos por los parámetros adicionales (podemos dejar los valores predeterminados aquí):

• Nombre de la entidad: CarrierAgentLocation
• Nombre del parámetro de identificación del agente: carrierAgent
• Nombre del parámetro de localización: location
• ...
• Habilitar depuración (sonido): Si habilitamos este parámetro, nuestro dispositivo emitirá un sonido cada vez que envíe una ubicación al servidor.
• Habilitar depuración (vibración): Si habilitamos este parámetro, nuestro dispositivo vibrará cada vez que envíe una ubicación al servidor.

Ahora podemos configurar los parámetros de comunicación:

• Protocolo de comunicación: GraphQL | MQTT
• URL de GraphQL: Aquí tenemos que indicar la URL donde hemos instalado nuestro servidor de NileDB.
• Distancia mínima: Este parámetro indica la distancia mínima que nos tenemos que mover para que se envíe una nueva ubicación al servidor.
• Intervalo de tiempo mínimo: Este parámetro indica el intervalo de tiempo mínimo que tiene que pasar para enviar una nueva ubicación al servidor.

Finalmente, podemos activar el servicio:

• Identificación de agente: Este es el número de identificación del agente que hemos creado antes.
• Activación de servicio: Asegúrate de activar el servicio para que se puedan enviar las ubicaciones.

Ahora puedes comprobar que la app está enviando ubicaciones ejecutando la siguiente consulta GraphQL:

{
  CarrierAgentList {
    id
    firstName
    lastName
    
    locations: CarrierAgentLocationListViaCarrierAgent {
      timestamp
      location
    }
  }
}

A partir de aquí, puedes desarrollar tu web integrando las posiciones que se devuelven por el servicio GraphQL, ...., o verlas en un mapa de Google, .....

Esto es todo amigos.

Como puedes ver, es muy fácil integrar NileDB y adaptarlo a tus requisitos.

Muchas gracias. ;-)