El portal de transparencia que publica los convenios, el gestor documental que necesita los expedientes, el padrón que consulta el callejero: cada sistema se da de alta aquí como una conexión, recibe su llave y pregunta directamente. Se autoriza módulo a módulo, y no hay forma de abrirlo todo de una vez.
Las conexiones las da de alta quien administra la entidad · Cada llamada queda en el registro del módulo al que llama
El problema que resuelve
Es lo que se hace cuando no hay otra: alguien descarga una hoja el primer lunes de mes, se la manda a quien mantiene el otro programa, y ese fichero con datos del ayuntamiento acaba en un correo, en un pendrive y en tres carpetas. Aquí el otro sistema pregunta directamente, con una llave que se puede cortar, y de cada pregunta queda rastro.
Una conexión por sistema
Para qué sistema es —el sistema, no la persona—, qué módulos necesita, si solo lee o también escribe, y hasta cuándo vale. Toda conexión caduca, como máximo a los tres años: es lo que evita que quede una llave viva de la que ya no se acuerda nadie.
Datos personales
Cuando entre los módulos marcados hay alguno que guarda datos de vecinos o de la plantilla, la pantalla dice qué guarda cada uno y enseña los campos concretos que van a salir por la puerta: documento de identidad, domicilio, teléfono, datos de salud, retribuciones. No después de crear la llave: antes.
Documentación y prueba
Las listas, los campos, los tipos, los obligatorios y las opciones de cada desplegable salen de lo que el módulo declara: si mañana añade un campo, aparecerá allí sin que nadie escriba nada. Esa es la página que se le manda a quien vaya a programar la integración, y quien prefiera un fichero OpenAPI también lo tiene.
Qué incluye
Quien administra la entidad reparte llaves; el resto puede mirar qué expone cada módulo y leer la documentación.
Cuántas puertas hay abiertas, cuáles permiten escribir, cuáles caducan pronto y qué reclama atención.
Módulo a módulo: si está abierto en esta entidad, qué guarda y qué listas y campos se pueden leer o escribir.
Las llaves dadas: para qué sistema, qué módulos alcanza, quién la creó, cuándo se usó por última vez y cuándo caduca.
Módulo, lista y llave: se ve el código que devuelve el servidor, lo que ha tardado y la respuesta entera, con su línea de curl.
La página que se le manda a quien programe la integración, generada del propio módulo, más el fichero OpenAPI para quien lo prefiera.
Conexiones creadas y revocadas, intentos con llaves que no valen y fallos. Unos cuantos seguidos desde la misma dirección no son un despiste.
Cada llamada que hace un sistema de fuera queda apuntada en el registro del módulo al que llama, con el nombre de la conexión que la hizo.
Los módulos que no declaran lo que guardan también se integran: la plataforma deduce sus listas y sus campos, y dice en la documentación hasta dónde llega lo que se sabe de ellas.
Corta el acceso al instante. Las revocadas y las caducadas se quedan en su apartado, para que conste que existieron y quién las creó.
Hasta dónde llega
Un módulo que mira a los demás, con sus límites escritos antes de que nadie se los encuentre.
Es un módulo y no una pantalla de Administración porque lo que hace se decide entidad por entidad: qué abre el Ayuntamiento no tiene por qué ser lo que abre el Patronato. Hereda de la plataforma el marco, los permisos, la visita guiada y el registro.
Esto abre los datos de MyGov a otros programas del ayuntamiento; no es un bus de integración ni sustituye a las plataformas de interoperabilidad de la Administración.
Preguntas frecuentes
Poco: llamadas REST con la llave en la cabecera de autorización y respuestas en JSON, con filtros, orden y paginación. Se le manda la página de documentación del módulo —generada del propio módulo, así que no está desfasada— y, si trabaja con herramientas modernas, el fichero OpenAPI, con el que su editor se construye solo las llamadas. Si al otro lado no lo necesitan, con la página basta.
Se revoca la conexión y se crea otra, que es un minuto. La llave se enseña una única vez al crearla y después solo queda su huella, así que nadie —tampoco quien administra— puede volver a verla. Es incómodo un día y tranquilizador todos los demás.
Sí. Cada llamada queda apuntada en el registro del módulo al que llama, con el nombre de la conexión que la hizo: eso se consulta en el propio módulo, no aquí. Y en esta zona queda el movimiento de las llaves: quién creó cada una, cuándo se revocó y los intentos con llaves que no valen.
Unos cuantos módulos vinieron de fuera —Presupuesto, Capítulo 1, Control Interno, el Asistente de Pliegos, Licitaciones, Servicios Sociales y el Conversor— y no declaran qué guardan. Para que también se puedan integrar, la plataforma mira lo que tienen guardado y deduce sus listas y sus campos. Se leen igual que las demás, pero lo que se puede prometer de ellas es menos: los nombres son los internos del módulo, el tipo es el probable y un campo que hoy no aparece en ningún registro no sale en la documentación. La pantalla las marca como deducidas y dice de qué clave salen.
Solo autorizándolo aparte, con una casilla que viene apagada a propósito, y sabiendo dos cosas. Una: en una lista declarada la plataforma comprueba los obligatorios, los tipos y los valores admitidos antes de guardar, y en una deducida no hay nada de eso —y las deducidas son justo las del presupuesto y las de la nómina—. Dos: lo que se escriba se queda en la copia del servidor; el módulo no lo lee de vuelta y lo reescribirá con lo suyo la próxima vez que alguien lo abra. Sirve para corregir o completar lo que la API sirve, no para dar de alta nada dentro del módulo.
Cuatro cosas, y la pantalla las señala: las conexiones que no se han usado nunca (o el sistema no está montado, o la llave se quedó por el camino, y en los dos casos hay una puerta abierta que nadie usa); las que se han quedado sin nadie a quien preguntar; los módulos con datos personales abiertos, para comprobar que la cesión sigue teniendo amparo y sigue haciendo falta; y el movimiento, donde quedan los intentos con llaves que no valen.
Pide una demostración: damos de alta una conexión de ejemplo, probamos la llamada en pantalla y enseñamos la documentación que recibiría quien mantiene tu otro programa.
La demostración se hace sobre una entidad de ejemplo, sin datos reales.