Aplicación Web

Está desarrollada en Golang(https://golang.org/) usando el modelo MVC. El código está en el siguiente repositorio:

GitHub - ltru0495/beegons-v2GitHub

La estructura del proyecto es el siguiente:

Estructura del proyecto

*Las carpetas vendor y data no están incluidas en el repositorio.

• assets: Archivos Javascript y Css.

• config: Archivo de configuración para cargar las variables de entorno.

• controllers: Controladores para el manejo de rutas.

• data: Carpeta creada al usar docker-compose para cargar el entorno, permite la persistencia de los datos.

• models: Estructuras definidas para el modelo de datos usados.

• routers: Rutas definidas.

• templates: Archivos HTML, se hace uso de templates de Golang. (https://golang.org/pkg/html/template/)

• utils: Otras funciones.

• vendor: Dependencias usadas para el proyecto, estas se encuentran en el archivo Gopkg.toml. Es recomendable usar go dep para descargarlas. (https://github.com/golang/dep)

Backend

Config

• config.go: Lee las variables de entorno del archivo .env. En caso se ejecute con docker-compose, los hostnames deben ser los especificados en docker-compose.yml.

HOST=127.0.0.1
HOSTNAME=beegons
PORT=9000
DB_USERNAME=
DB_PASSWORD=
DB_HOST=mongo-db
DB_PORT=27017
DB_DATABASE=test
ORION_CB_HOST=orion
ORION_CB_PORT=1026
CYGNUS_HOST=cygnus
CYGNUS_PORT=5050
CYGNUS_DATABASE=sth_default
FLINK_HOST=taskmanager     
FLINK_PORT=9001

Utils

• init.go:

  • func Init():

    Se hace un llamado a las funciones para inicialización(CheckOrion y SetLogger), en golang se puede tener una función init y se llamará automáticamente al iniciar la ejecución, sin embargo lo puse en mayúscula para que poder controlar el orden de llamado de las funciones.

• logger.go

  • func SetLogger():Abre el archivo de logs para escribir(log.txt). Todo lo que se escriba con la función log.Print... se escribirá en ese archivo.

• orion.go: En este archivo están las funciones para realizar consultas a Orion Context Broker.

  • func CheckOrion():Hace una petición GET a Orion para verificar que obtenga respuesta. En caso falle se corta la ejecución.

  • func GetEntity(entityID string, itf interface{}) (err error): Hace una petición HTTP GET a Orion (revisar la API de Orion https://telefonicaiotcb.docs.apiary.io/) por la entidad con Id entityID, el resultado lo almacena en la interfaz itf, al hacer uso de una interfaz se puede reutilizar esta misma función para los ditintios tipos de datos definidos.

  • func GetEntities(entityType string, itf interface{}) (err error): Petición GET a Orion, filtra por tipo entityType, se espera un array de entitidades el cual se almacena en itf.

  • func PostEntity(entity interface{}) error: Petición POST a Orion, se usa para registrar la entidad entity en Orion.

  • func PostSubscription(data interface{}) error: POST para registrar una subscripción.

• templates.go:

  • func init() :Inicializa los templates, especificando la carpeta donde se encontrarán los archivos html.

  • func RenderTemplate(w http.ResponseWriter, filename string, data interface{}): Envía el template listo para ser mostrado en la parte del usuario. Librería usada: https://github.com/thedevsaddam/renderer. filename es el nombre que se asignó al template, data corresponde a las variables que se usarán en los templates.

• vars.go: Se leen las variables de entorno especificadas en el archivo .env en el formato adecuado para su uso.

  • func GetOrionURL() string

  • func GetCygnusURL() string

  • func GetDBURL() string

  • func GetAppDBName() string

  • func GetCygnusDBName() string

  • func GetFlinkURL() string

  • func GetAlertURL() string

• ws.go: Funcionesy variables para el manejo de Websockets(https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API)

  • var wsAlertHub Hub: para envío de alertas.

  • var wsDataHub Hub: para envío de datos.

  • Se usó este código como guía : https://github.com/gorilla/websocket/tree/master/examples/chat

Templates

Archivos html, se hace uso de templates de Golang. Cada archivo define un nombre con el que será llamado al momento de ser renderizado, este proceso se lleva acabo en los controllers. En la carpeta partials están porciones que se incluyen en varias páginas para no tener que repetir el código.

Routers

Se usó la librería gorilla mux (https://github.com/gorilla/mux) para establecer las rutas.

• api.go: especifica las rutas para la api. Los controladores correspondientes están en la carpeta controllers/api. Todas las funciones aceptan solo peticiones GET.

  • /api/module/{moduleid}:

    • controlador: api.Module

    • ejm: /api/module/urn:ngsi-ld:Module:MOD1

• /api/module/{moduleid}/parameters

  • controlador: api.ModuleParameters

  • ejm: /api/module/urn:ngsi-ld:Module:MOD1/parameters

• /api/modules

  • controlador: api.Modules

  • ejm: /api/modules

• /api/module/{moduleid}/realtime

  • controlador: api.ModuleRealtime

  • ejm: /api/module/urn:ngsi-ld:Module:MOD1/realtime

• /api/data/{moduleid}/{parameter}/{start}/{end}

  • controlador: api.HistoricalData

  • ejm: /api/data/urn:ngsi-ld:Module:MOD1/humidity/2019-15-12T00:00Z/2019-17-12T00:00Z

• app.go: rutas relacionadas con el front end de la aplicación.

  • /user/create:

    • controlador: controllers.UserCreate.

    • GET: se muestra el formulario de registro para usuario.

    • POST: se recibe el formulario de registro para usuario.

  • /users:

    • controlador: controllers.UserTable

    • GET: muestra una tabla con los usuario.

  • /module/create:

    • controlador: controllers.ModuleCreate

    • GET: se muestra el formulario de registro para módulo.

    • POST: se recibe el formulario de registro para módulo.

  • /module/modify:

    • controlador: controllers.ModuleModify

    • GET: formulario para modificación de módulo.

    • POST: recive formulario de modificación de módulo.

  • /modules:

    • controlador: controllers.ModuleTable

    • GET: muestra tabla de módulos.

  • /alerts:

    • controlador: controllers.Alerts

    • GET: muestra alertas recibidas.

  • /charts/realtime:

    • controlador: controllers.ChartsRealtime

    • GET: muestra página con gráficos en tiempo real.

  • /charts/historical:

    • controlador: controllers.ChartsHistorical

    • GET: muestra página con gráficos históricos.

  • /alerts/notify:

    • controlador: controllers.AlertsNotify

    • POST: usado como ruta donde Orion envía las alertas registradas en las subscripciones.

  • /data/notify:

    • controlador: DataNotify

    • POST: usado como ruta donde Orion envía los datos registrados en las subscripciones.

  • /error:

    • controlador: Error

    • GET: Pantalla de error.

  • /maps/sensors:

    • controlador: controllers.MapSensors

    • GET: muestra mapa con sensores.

  • /maps/parking:

    • controlador: controllers.MapParking

    • GET: muestra mapa con sensores de parqueo.

• ws.go: rutas usadas para websockets. Se usó la librería https://github.com/gorilla/websocket

  • /ws/alert:

    • controlador: controllers.WSAlert

    • GET: establece conexion por Websockets para gestionar el envío de alertas en tiempo real a la web.

  • /ws/data:

    • controlador: controllers.WSData

    • GET: establece conexión por Websockets para gestionar el envío de datos en tiempo real a la web.

• router.go: Inicializa todas las rutas haciendo un llamado a las funciones de los archivos mencionados anteriormente.

  • func InitRoutes() *mux.Router

Models

Archivos relacionados al manejo de estructuras de los modelos definidos.

• database.go: funciones para conexión con la base de datos mongodb. La librería usada es: https://github.com/mongodb/mongo-go-driver.

  • var mClient *mongo.Client:variable usada para hacer consultas a la base de datos.

  • func ConnectToDB(): llama a las funciones connect y ping.

  • func connect():establece conexión con la base de datos, la url es la especificada en las variables DATABASE_HOST en el archivo .env.

  • func ping():verifica la conexión a la base de datos.

  • func getDatabase(dbName string) *mongo.Database: devuelve una conexión a la base de datos con el nombre dbname.

  • func GetCygnusDatabase() *mongo.Database: devuelve una conexión a la base de datos Cygnus, usada para almacenar los datos.

• dataObserved.go

  • type DataObserved struct

• • type ModuleAndData struct Se compone de información de un Módulo y los datos registrados para èl. Se usa para los gráficos en tiempo real.

  • func mapToDataObserved(m map[string]interface{}) (d DataObserved)permite obtener una estructura de tipo DataObserved a partir de una respuesta de Orion,

  • func GetDataObserved(moduleid string) (d DataObserved, err error) Hace una consulta a Orion y devuelve la estructura DataObserved correspondiente.

  • func FilterDataByDate(id, dataType, parameter string, -start, end time.Time) (d []CygnusDocument, err error) Hace una consulta a la base de datos donde Cygnus almacena los datos y devuelve un array de estructuras CygnusDocuments(orion.go) de acuerdo a los parámetros especificados: id, parámetro, fecha de inicio y fecha final. Es usada para los gráficos históricos.

  • func GetLastData(id, dataType, parameter string, n int64) (d []CygnusDocument, err error) Hace una consulta a la base de datos y devuelve los últimos valores registrados para un módulo.

  • func FixTimeZone(d []CygnusDocument) []CygnusDocument Corrige la zona horaria.

• module.go

  • type Module struct

• • func (m Module) DecodeModuleForm(r http.Request) error Recive el form de la petición POST y lo pasa a una estructura. Se asignan las coordenadas a Coordinates solo temporalmente, luego son asignadas como objecto geojson en Location.

  • func (m *Module) CreateModule() (err error) Envía un post request a Orion con el fin de crear la entidad correspondiente. Hace uso de PostEntity(utils/orion.go)

  • func (m *Module) CreateDataObserved() (err error) crea una entidad DataObserved en Orion a partir del módulo. Hace uso de PostEntity(utils/orion.go)

  • func (m *Module) CreateAlert() (err error) crea una entidad Alert en Orion a partir de un módulo. Hace uso de PostEntity(utils/orion.go)

  • func (m *Module) CreateAlertSubscription() (err error) Crea una subscripción en Orion especificando la url para las alertas(utils.GetAlertURL() en utils/vars.go). Hace uso de PostSubscription(utils/orion.go).

  • func (m *Module) CreateCygnusSubscription() (err error) Crea una subscripción en Orion especificando la url para las cygnus(utils.GetCygnusURL() en utils/vars.go) . Hace uso de PostSubscription(utils/orion.go).

  • func (m *Module) CreateDataSubscription() (err error) Crea una subscripción en Orion especificando la url para la aplicacion web (la misma que utils.GetAlertURL() en utils/vars.go) . Hace uso de PostSubscription(utils/orion.go).

  • func (m *Module) CreateFlinkSubscription() (err error) Crea una subscripción en Orion especificando la url para Apache Flink(utils.GetFlinkURL() en utils/vars.go) . Hace uso de PostSubscription(utils/orion.go).

  • func GetAllModules() (modules []Module, err error) Hace una petición GET a Orion y devuelve todos los módulos registrados como un array.

  • func GetModule(id string) (module Module, err error) Hace una petición GET a Orion especificando el id del Mòdulo.

• orion.go

• response.go