Anexo: API de programación en javascript (capa bas)

Índice

Común
Base
Clases, Campos y Clasificaciones
Conceptos
Referencias
Directorios
Gráficos
Mapas
Usuarios y Permisos


Esta página se refiere a las funciones del API asociadas a un objeto bas, la instancia de base de datos accesible desde el programa javascript.

Vea el tema Anexo: API de funciones generales (capa ingra) para ver otro amplio conjunto independiente del acceso a BD (manejo de cadenas, clases, archivos, fechas, flujo...

 

Todas estas funciones son asíncronas, por lo que el último parámetro es una función de callback. El parámetro 'op' es variable, puede incluir un objeto con distintas variables, pero es OPCIONAL, no hay que dejarlo vacío, simplemente no ponerlo cuando no se especifica. En la descripción, los valores indicados son los de defecto.

Todas pueden devolver un objeto con la variable 'error' y además las variables que se especifiquen.

Estas funciones son relativamente bajo nivel, para uso en informes del cliente. Las funciones ingrid.<clase>.<verbo> son de más alto nivel, referentes al ámbito de una clase concreta y no se documentan porque son cientos en toda la aplicación. Ambas capas se pueden usar indistintamente desde los procedimientos.

LEyenda colores:
- azul: en otro módulo que IngridAPI
- negrita: ampliamente utilizada
- *: pendiente revisar parámetros

Común

usosLeeBase (servidor,cod,cb) Devuelve los datos de BD administrativa ingrid-usos para la BD {cod} > {cod:basename, tam,res,obs,... enJson,enBson, maquina}
usosLeeBases (meta,cb) Devuelve un array con la estructura de bases y sus datos de uso > {basl:[{cod:basename, ...}]}
usosGrabaObservaciones (meta,cb) Graba en campo observaciones de la BD 'cod' en la BD de administración ingra ingrid-usos. Devuelve {result}. Sólo para usuario INGRA
 
adminLeeBasesJson (meta,cb) {filtra:1} > {basl:[name]};
adminLeeBasesMongo (meta,cb) {filtra:1} > {basl:[name], databases:[{name,sizeOnDisk,empty}]};
adminLeeUsuarios (meta,cb) {} > {usuarios:[{conexionId,basedatos,usuario,res}]}
adminEnviaComunicacion (meta,cb) {conexionId,texto} > {} > {orden:'recibeComunicacion', mensaje, conexionId, basedatos, usuario}
 
comunLeeClases (meta,cb) {} > {dClases} EXPER
comunLeeConcepto (meta,cb) {find,data,option} > {error,doc}
comunLeeConceptos (meta,cb) {find,data,option} > {error,docl}
comunLeeDescompuestos (meta,cb) {find,data,option} > {error,docl}
comunGrabaConceptos (meta,cb) {doc|docl, upsert:true, ope:replace|set|unset|*set/unset} > {error,result} SOLOINGRA
comunRegrabaConceptos (meta,cb) {doc|docl} > {error,result} SOLOINGRA
 
comunLeeIndice (meta,cb) {id} > {docs} docs:{_id:{_id,res,bus,desl,estilo}}
 
comunSincroniza (meta,cb) {_idl, soloEstilos:0}} > {docl} si soloEstilos:doc:{cla,ico,col}
comunTrasladaClases (meta,cb) {idl} > comunGrabaConceptos

Base

Por implementar:

estadoBase (cb) Consulta y devuelve estado de la base > {estado}
existeBase (cb) Devuelve
chequeaBase (cb) Repara BD y referencias, crea campos inexistente y cambia tipos
 
mongodump (meta,cb) Volcado de BD a formato binario BSON en el archivo 'arcb'. op={gzip:true} lo vuelca a formato comprimido con extenión .gz (comando ejecutado: mongodump -d nombreBase -c con --forceTableScan [--gzip] con caminos ABSOLUTOS
mongorestore meta,cb) Importación en BD dekl archivo binario .bosn 'arcb' (o comprimido .gz). op:{gzip:0} lo recupera de formato comprimido (comando ejecutado: mongorestore -d nombreBase --drop [--gzip] --archive=archivoBson con caminos ABSOLUTOS
mongoexport (meta,cb) {nombreBase, archivoJson:nombreBase+'.json', libera:null} > {error} // mongoexport -d nombreBase -c con --jsonArray| > archivoJson si enJson --jsonArray
mongoimport (meta,cb) {nombreBase, archivoJson:nombreBase+'.json', enJson:null} > {error} // mongoimport -d nombreBase -c con --drop|--upsert|--mode merge < archivoJson si libera --drop si merge --mode merge sino --upsert
eliminaMongo (meta,cb) Elimina BD del motor, opcionalmente, con un archivo JSON, {nombreBase, archivoJson:nombreBase+'.json', libera:null} > {error}
 
nuevaBase (meta,cb) Crea BD {nombreBase, servidor=1} > crea directorio, copìa nuevo
copiaBase (meta,cb) Copia BD {nombreBase, nombreCopia} > copia directorio, mongoexport(nombreBase,nombreCopia.json), mongoimport(nombreCopia.json)
renombraBase(meta,cb) Cambia de nombre BD re-creándola (exportando e importando con el nuevo nombre). {nombreBase, nombreNuevo} > renombra directorio, mongoexport(nombreBase,nombreNuevo.json), mongoimport(nombreNuevo.json)
eliminaBase (meta,cb) Elimina BD (del motor y directorio de archivos) {nombreBase}
 
creaCopiaBson (arc,cb){nombreBase} > (comando ejecutado: mongodump(nombreBase,archivoBsonN))
recuperaCopiaBson (arc,cb){nombreBase, numeroCopia} > (comando ejecutado: mongorestore(nombreBase,archivoBsonN))
creaCopiaJson (arc,cb){nombreBase} > (comando ejecutado: mongoexport(nombreBase,archivoJsonN))
recuperaCopiaJson (arc,cb){nombreBase, numeroCopia} > (comando ejecutado: mongoimport(nombreBase,archivoJsonN))
 
sesionAbre (meta,cb) {basedatos,usuario,clave}
sesionCierra (meta,cb) {}
sesionNavega (meta,cb) {_id}
sesionNavegaBusca (meta,cb) {res,bus}
 
indiceTextoElimina (meta,cb) {}
indiceTextoCrea (meta,cb) {campos} > {results} defecto:campos:{res:10,tex:3,indiceRefl:1}
chequeaBase1 (cb) Con interface, con op= {}

Clases, Campos y Clasificaciones

Por implementar:

cuentaClases (meta,cb) {} > {cambios:[{_id,docn}],nuevos:[{_id,cla,cod,docn}],viejos:[{_id}]}
copiaClase (meta,cb) {clacod,clacod2,prioridadOrigen} > {docn,docn0,cla2} Copia clase y conceptos de la clase
cambiaClase (meta,cb) {clacod,clacod2,prioridadOrigen} > {} Cambia clase y conceptos de la clase
eliminaClase (meta,cb) {clacod||[], incluyeSubclases=0, soloConceptos=1} > {clacodl,soloConceptos,docn}
compruebaClase (meta,cb) {clacod} > {error,cambios} compueba {cla,cod}
cambiaReferenciasClase(meta,cb)
 
Campos de clases y campos de relaciones(camrelcod)
cuentaCampos (meta,cb) {clacod,[camrelcod]} > {caml,nuevos} nuevos:{cod:docn}
analizaCampos (meta,cb) {clacod,[camrelcod],graba} > {caml o campos} campos:{cod:{tip,docn,obs}} si graba caml:cla.caml
 
eliminaCampo (meta,cb) {clacod,[camrelcod], camcod||[], soloValores=1} > {caml,docn}
agregaCampo (meta,cb) {clacod, cam:{}}
cambiaValoresCampo (meta,cb) {clacod,[camrelcod],camcod,[camrelcod],[valori],[valdes]} > {docn} si valori===undefined pone sin definir, si valdes===undefined elimina
incrementaValoresCampo(meta,cb) {clacod,camcod,valori],valdes} > {docn} si valori===undefined todos
copiaCampo1 (meta,cb) {clacod,camori,camdes} > {docn}
copiaCampo (meta,cb) {clacod,camori,camdes} > {campo} CAMBIO DE TIPO
 
cambiaCodigoCampo (meta,cb) {clacod,camori,camdes} > {docn} antes: renombraCampo
cambiaValorCampo (meta,cb) {find,camcod,camval(expresionRegular(d,i))} > {docn)
compruebaValoresCampo(meta,cb) {clacod,camcod,prueba} > {docn)
cambiaTipoCampo (meta,cb) {clacod,[camrelcod],camori,[camdes],camtip} > {h)
 
cuentaClasificacion (meta,cb)
copiaClase2 (cla,cb) > (cla2)
cambiaClase2 (cla,cb) > (cla2)
eliminaClase2 (cla,cb) > (2)claseYconceptos (1)soloConceptos
eliminaClase1 (cla,cb) > (2)claseYconceptos (1)soloConceptos

Conceptos

Los parámetros 'bus' son búsquedas en lenguaje mongoDB con objeto find o búsquedas en lenguaje de Ingrid

leeDistintos(meta,cb) Devuelve lista de los elementos distintos consultando un campo (consulta mongo.distinct {campo}) > {vall}
*leeNumero (meta,cb) Cuenta los elementos de un campo (consulta mongo.count {_id|_idl|find, sort, data}) > {docn}
 
leeConcepto (meta,cb) Devuelve el primer elemento buscado (consulta mongo.findOne {_id|_idl|find, sort, data}) > {error,doc} control de permisos solo en servidor
leeConceptos (meta,cb) Devuelve lista de documentos completos (consulta mongo.find {_id|_idl|find, sort, data}) > {error,docl,docn,meta} control de permisos solo en servidor
*sesionNavega (meta,cb) meta:{ _id, modo:{busqueda}... } | _id > sesionNavega2
*sesionNavegaBusca (meta,cb) meta:{ res,bus, ... } > sesionNavega2
 
creaConceptos (meta,cb) mongo.insert {doc|docl, ordered:true} > {error} graba, si existe error (con ordered:false no se para al dar un error)
recreaConceptos (meta,cb) mongo.save {doc|docl} > {error} crea, si existe regraba
grabaConceptos (meta,cb) mongo.setN {doc|docl, ordered:true} > {error} graba campos de cada doc, deben existir PARCIAL
renombraConceptos (meta,cb) cambiaId {id1,id2|id1l,id2l} > {error} cambia identificador
recodificaConceptos (meta,cb) cambiaId {find, tam} > {error} cambia identificador
eliminaConceptos (meta,cb) mongo.remove {_id|_idl|find} > {error}
 
grabaCampos (meta,cb) mongo.set {_id|_idl|find, data, multi} modifica campos { $set: {hi: 'there'}, $unset: {hi: ''} } comprueba cambios
eliminaCampos (meta,cb) mongo.unset {_id|_idl|find, data, multi}
renombraCampos (meta,cb) mongo.rename {_id|_idl|find, data, multi} renombra campos { $rename: { 'age' : 'edad' } }
incrementaCampos (meta,cb) mongo.inc {_id|_idl|find, data, multi} incrementa valor { $inc: { age : 1 } }
 
renombraCampoLista (meta,cb) mongo.rename {_id|_idl|find, data, multi} renombra campos { $rename: { 'age' : 'edad' } }
 
agregaLista (meta,cb) meta:{_id|_idl|find, data:{campoLista:valor|valores}}
eliminaLista (meta,cb) meta:{_id|_idl|find, data:{campoLista:valor|valores}}
 
procesaInforme (meta,cb) {find, campoLista, campo1, campo2} renombra campos de lista

Referencias

montaReferencias (meta,cb) {todos,_id,elimina,noGraba} > {mensajes}
chequeaReferencias (meta,cb) {todos,_id,elimina,noGraba} > {mensajes}
cuentaReferencias (meta,cb)
 
__cambiaId (meta,cb) meta:{id1,id2} > {}
__cambiaIds (meta,cb) meta:{id1l,id2l} > {}

Directorios

importaJson (arc,op,cb) Importa archivo json, {archivo, [clasesNo=","|[]], [clasesSi=","|[]]} > {docn,clan,[clases]}
exportaJson (arc,op,cb) Exporta archivo json, {archivo, [condicion={}], [campos={}], jsonArray=0} > {docn]}
eliminaJson (op,cb) Elimina todo el contenido de la base de datos, si tiene éxito, devuelve el objeto array con todas las del motor. op:{nueva:1,plantilla} > {dBases}
 
existeArchivo (arc,cb) Comprueba existencia de archivo o URL > 0|1 permiso L
leeArchivo (arc,op,cb) Lee archivo o URL en formato UTF8, op:{encoding} > {data} permiso L
leeArchivoAnsi (arc,op,cb) Lee archivo o URL en formato ANSI, op:{...} > {data} permiso L
leeArchivoJson (arc,op,cb) Lee archivo o URL en formato JSON, op:{} > {data} permiso L
grabaArchivo (arc,data,op,cb) Graba archivo, op:{creaDir:0, encoding:0, bom:0} > {} permiso C
grabaArchivoUtf (arc,data,op,cb) Graba archivo en formato UTF8, op:{creaDir:0} > {} permiso C; encoding='utf8'; bom=1
agregaArchivo (arc,data,op,cb) Agrega datos a archivo > {} permiso C
copiaArchivo (arc,destino,op,cb) Copia archivo > {} permiso C
mueveArchivo (arc,destino,op,cb) Mueve/Renombra archivo > {} permiso C
eliminaArchivo (arc,op,cb) Elimina archivo > {} permiso D
 
Todos con camino relativo a raíz de BD
leeDirectorio (dir,op,cb) {dir, esdir:null, reg:null, ext:null, orden:1, nombreBase(solo admin==2) }} > {arcl:[nom]} permiso L
leeDirectorioO (dir,op,cb) {dir, esdir:null, reg:null, ext:null, orden:1, nombreBase(solo admin==2) }} > {arcl:[{nom,tam,esdir,ctime,mtime,atime}]} permiso L
creaDirectorio (dir,op,cb) {dir} > {} permiso C
eliminaDirectorio (dir,op,cb) Elimina directorio aunque tenga contenido. permiso D
calculaDirectorio (dir,op,cb) {dir} > {} permiso D
 
copiaArchivos (dir,op,cb) {dir, noml|reg, desl|destino, regraba:1, siExiste:0} > {} permiso C
mueveArchivos (dir,op,cb) {dir, noml|reg, desl|destino, regraba:1, siExiste:0} > {} permiso C
eliminaArchivos (dir,op,cb) {dir, noml|reg} > {} permiso D
mueveMascara (origen,destino,op,cb) {origen,destino} > {} permiso C; admite varios *
 
agregaArchivo (arc,op,cb) {arc, {file|url|html|origen} arc:incluye camino relativo, crea subdirectorios
 
directorioZip (azip,cb) {azip} > {arcl:[entryName],dirl:[entryName]} permiso C
leeZip (azip,arc,cb) {azip,arc} > {data} utf8 permiso C
 
enviaCorreo (transporter,mail,cb) { transporter:{service,auth:{user,pass}}, mail:{from, to, subject, text, html, attachments:[{filename, content, path}]} > {info:{response}}
html2pdf (origen,destino,op,cb) {origen,destino,op} op:{a4h,a4v,a3h,a3v,mar,...-*,wk)
html2ima (origen,destino,op,cb) {origen,destino,op} op:{-*,wk)

Gráficos

montaGraficoBajaMedia (meta,cb) >{ima:{cod,anc,alt,col,tam}} utiliza cab.graBaja cab.graMedia gm.identify gm.resize gm.noProfile
montaGrafico (meta,cb) {cod, _id, pos:null, tam:null} montaBajaMedia + grabaGral > {ima,gral}
 
agregaGrafico (meta,cb) Agrega gráfico. {cod, file|url|html|arc, [docid],[primero]} > copia alta, monta original y miniaturas, [graba doc.gral] > {ima}
 
Sobre toda la base
gra= {};
gra.comprueba (meta,cb) {find,recrea} > original,alta,media,baja gra:{anc,alt,tam,orianc,orialt,oritam}
gra.compruebaReferencias (meta,cb) Comprueba referencias a conceptos gráficos de otros conceptos, crea si no existen; con.gral > gra // meta:{find:''}
gra.compruebaMetadatos (meta,cb) Comprueba/recrea metadatos de archivos en conceptos gráficos. Si no existen conceptos gráficos de archivos en alta u original, los crea // meta:{find:'',recrea:false}
gra.compruebaMiniaturas (meta,cb) Comprueba/recrea miniaturas, utiliza tamaño de baja y media resolución; crea si no existe, elimina si sobran // meta:{find:'',recrea:false}
gra.compruebaOriginales (meta,cb) Comprueba/recrea originales, utiliza tamaño máximo de alta // meta:{find:'',recrea:false}
gra.leeExif meta,cb) Lee info en imagen. {arc|cod} > {data:{anc,alt,fec,x,y,dir},exif});
gra.rota (meta,cb) Rota gráficos. {id|idl,ang} ang:90,180,270 > {} rota alta y rehace miniaturas
 
sharp= {};
sharp.redimensiona (meta,cb) ­® {ori,des,tam} > {anc,alt,tam}
sharp.miniaturas (meta,cb) ­® {arcAlta, arcMedia, arcBaja, tamMedia, tamBaja} > {media:{anc,alt,tam}, baja:{anc,alt,tam}}
sharp.redimensiona2 (meta,cb) ­® {origen, destino|original, dimMaxima} > {gran,gram}
sharp.miniaturas2 (meta,cb) ­® {dirBase, tamBaja(96), tamMedia(256), recrea(0)} > {gran,gram}

Mapas

importaSeccionesCensales (meta,cb) Importa secciones censales de un municipio o provincia; {espid}
importaCartociudad (meta,cb) Importa cartografía de CartoCiudad de un municipio o provincia; {espid]
importaMunicipio (meta,cb) Importa seccionesCensales, construye envolventes superiores, importa CartoCiudad, .... de municipio o provincia {espid}
 
mapas Crea objeto de georregerencias
mapas.chequea (meta,cb) Chequea mapas; {} > busca doc.geol > doc.rec graba si distinto
mapas.buscaCercano (meta,cb) Busca punto cercano; {pun|x,y} > {docl}
mapas.buscaDentro (meta,cb) Busca punto dentro; {pun|x,y|rec|doc.georec, margen, completos} > {docl}
 
mapas.importa (meta,cb) Importa; {dirOrigen, extOrigen, epsg, recursivo, capsi,capno, camid,camcla,camcod, clacod,codsec, prueba} > {}
mapas.exporta (meta,cb) Exporta; {arc, epsg, bus:'geol!!', caml:[], json, arc, sinVariables, porCapas} > {}; (.shp)porCapas (.dgn .dxg)sinVariables > {}
mapas.convierte (meta,cb) Convierte; {arcOrigen,...} | {dirOrigen,...} > {ms|num}
{arcOrigen, arcDestino:arcOrigen+extDestino, epsgOrigen:25830, epsgDestino:25830, extDestino|arcDestino, sinVariables} > {ms}
{dirOrigen:directotio|archivo, dirDestino:dirOrigen, epsgOrigen:25830, epsgDestino:25830, extOrigen:regular|extension, extDestino} > {num}
 
mapas.envolvente (meta,cb) Monta con envolventes las georreferencias de superiores; {clacod,[camcod],[prueba]} > graba geol en clase superior
 
inca Formato inca (formato geográfico de intercambio entre dxi, ingrid7 e ingrid8)
inca.exporta (meta,cb) Exporta formato inca; {bus|doc|docl, epsg:'', json=0, arc=''} > {inca|json|} cod=bas.basedatos res=bas.cab.res;
inca.importa (meta,cb) Importa formato inca; {arc, clase=''}} > {}
 
geojson Formato geojson (formato geográfico de intercambio con cualquier formato GIS o CAD)
geojson.exporta (meta,cb) Exporta formato geojson; {bus|doc|docl, epsg:'', json=0, arc=''} > {geojson|json|}
geojson.importa (meta,cb) Importa formato geojson; {arc, clase=''}} > {}
geojson.html (meta,cb) Exporta geojson encapsulado en html {arc, bus|doc|docl, epsg:'', google([RSTH]),bing([RSH]),zoom(0..23),opacity(0..1),altura(px),radio(px)}
 
geojson.troceaGeojson (meta,cb) Trocea un geojson en muchos utilizando una propiedad. {arc,pro,des} > {}
geojson.troceaEspacios (meta,cb) Reparte un geojson en contenedores utilizando busqueda geográfica {} > {arc,bus,capa=nombre(arc)}
geojson.importaCartociudad (meta,cb) importaCartociudad {dir, espl|bus|'cla=espsec', [capa]} > {}
 
dxi Formato DXI (formato geográfico de intercambio de INGRA)
dxi.lee (meta,cb) Lee archivo DXI {arc, epsh=bas.cab.epsg} > {dxi} dxi:{cod,res, rec, epsg, capl:{cod,res,pro,estilo,geol}, blol:{dxi}} estilo:{pentip,...}

Usuarios y permisos

Con un objeto usu={}
cambiaClave (claant,clanue,cb) Cambia clave o devuelve error si 'claant' no coincide