Módulo:Wikidata

[ver ·  · actualizar]

Documentación de módulo

Aún no se han escrito las instrucciones sobre este módulo. Añádelas.

--[[*********************************************************************************
    * Nombre: Módulo:Wikidata
    *
    * Descripción: Este módulo devuelve el valor o valores con o sin formato específico 
    *             a una propiedad de Wikidata. 
    *
    * Fecha última revisión: 6 de septiembre de 2014.
    *
    * Estado: En uso. 
    *
    *********************************************************************************`-- ]]
 
local p = {}
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
local es = mw.language.new('es')
local primera = true
local marco
 --[[ =========================================================================
            Mensajes de error
      ========================================================================= `-- ]]
 
local avisos = {
    ["errores"] = {
        ["property-param-not-provided"] = "Parámetro de la propiedad no proporcionado.",
        ["entity-not-found"] = "Entrada no encontrada.",
        ["unknown-claim-type"] = "Tipo de notificación desconocida.",
        ["unknown-snak-type"] = "Tipo de dato desconocido.",
        ["unknown-datavalue-type"] = "Formato de dato desconocido.",
        ["unknown-entity-type"] = "Tipo de entrada desconocido.",
        ["unknown-value-module"] = "Debe ajustar ambos parámetros de valor y el valor del módulo de funciones.",
        ["value-module-not-found"] = "No se ha encontrado el módulo apuntado por valor-módulo.",
        ["value-function-not-found"] = "No se ha encontrado la función apuntada por valor-función.",
        ["other entity"] = "Enlaces a elementos diferentes desactivado."
    },
    ["somevalue"] = "''valor desconocido''",
    ["novalue"] = ""
}
 --[[ =========================================================================
      Función para pasar el frame cuando se usa en otros módulos.      
     ========================================================================= `-- ]]
function p:setFrame(frame)
	marco = frame
end
 --[[ =========================================================================
      Función para identificar el ítem correspondiente a la página o otro dado.
              Esto último aún no funciona.      
     ========================================================================= `-- ]]


function SelecionEntidadPorId( id )
 
        if id and id ~= ''  then
            return mw.wikibase.getEntityObject( id )
        else 
            return mw.wikibase.getEntityObject()
        end 
 
end 
 
 
 --[[ =========================================================================
      Función que identifica si el valor devuelto es un ítem o una propiedad 
      y en función de eso añade el prefijo correspondiente     
     ========================================================================= `-- ]]
 
function SelecionEntidadPorValor( valor )
    local prefijo = ''
    if valor['entity-type'] == 'item' then
        prefijo = 'q' -- Prefijo de ítem
    elseif valor['entity-type'] == 'property' then
        prefijo = 'p' -- Prefijo de propiedad
    else
        return formatoError( 'unknown-entity-type' )
    end
    return prefijo .. valor['numeric-id'] -- Se concatena el prefijo y el código numérico
end
 
 --[[ =========================================================================
      Función auxiliar para dar formato a los mensajes de error      
     ========================================================================= `-- ]] 
 
function formatoError( clave )
    return '<span class="error">' .. avisos.errores[clave] .. '</span>'
end
 --[[ =========================================================================
      Función para determinar el rango     
     ========================================================================= `-- ]]
function getRango(tablaDeclaraciones)
 
	local rank = 'deprecated'
 
    for indice, declaracion in pairs(tablaDeclaraciones) do
        if declaracion.rank == 'preferred' then
            return 'preferred'
        elseif declaracion.rank == 'normal' then
            rank = 'normal'
        end 
    end
 
    return rank
end
 
 --[[ =========================================================================
      Función para determinar la declaracion o declaraciones de mayor rango    
     ========================================================================= `-- ]]
function filtrarDeclaracionPorRango(tablaDeclaraciones)
    local rango = getRango(tablaDeclaraciones)
    local tablaAuxiliar = tablaDeclaraciones
    tablaDeclaraciones = {}
 
    for indice, declaracion in pairs(tablaAuxiliar) do
        if declaracion.rank == rango then
            table.insert(tablaDeclaraciones, declaracion)
        end 
    end 
    return tablaDeclaraciones
end
 
 --[[ =========================================================================
      Función para seleccionar el tipo de declaración: Referencia, valor principal 
      o calificador      
     ========================================================================= `-- ]]
 
function seleccionDeclaracion(declaracion, opciones)
    local fuente = {}
    local propiedadFuente = {}
    local calificador = opciones.calificador
 
    if calificador ~= '' and calificador  and declaracion['qualifiers'] then
    	if declaracion['qualifiers'][mw.ustring.upper(calificador)] then
            return declaracion.qualifiers[mw.ustring.upper(calificador)][1] -- devuelve el calificador (solo devolverá el primer valor)
        else
        	return "" --Para que no lance excepción si no existe el calificador
        end
    elseif opciones.dato == 'fuente' and declaracion['references'] then
    	fuente = declaracion.references[1]['snaks']
        for k,v in pairs(fuente) do
            propiedadFuente = k
        end
        return declaracion.references[1]['snaks'][propiedadFuente][1]  -- devuelve la fuente (queda que se itinere la tabla)
    elseif (calificador == '' or not calificador) and (opciones.dato ~= 'fuente') then
        return declaracion.mainsnak -- devuelve el valor principal
    else 
    	return ''    
    end
end 
 
 --[[ =========================================================================
      Función para recopilar las declaraciones      
     ========================================================================= `-- ]] 
 
function p.getDeclaraciones(entityId)
 
 
    -- == Comprobamos que existe un ítem enlazado a la página en Wikidata ==
    if not pcall (SelecionEntidadPorId, entityId ) then 
    	return false
    end
    local entidad  = SelecionEntidadPorId(entityId) 
 
    if not entidad then
        return  '' -- Si la página no está enlazada a un ítem no devuelve nada
    end
 
    -- == Comprobamos que el ítem tiene declaraciones (claims) == 
 
    if not entidad.claims then
        return '' -- Si el ítem no tiene declaraciones no devuelve nada
    end
    -- == Declaración de formato y concatenado limpio ==
 
    return entidad.claims
end
 
 --[[ =========================================================================
      Función para  crear la cadena que devolverá la declaración     
     ========================================================================= `-- ]] 
     
local function valinQualif(claim, qualifs)
	local claimqualifs = claim.qualifiers
	local i,qualif
	local vals, vals1, datavalue, value
	
	if not claimqualifs then
		return nil
	end
	for i, qualif in pairs(qualifs) do
		vals = claimqualifs[qualif]
		if vals then
			vals1 = vals[1]
			if vals1 then
				datavalue=vals1.datavalue
				
				if datavalue then
					value = datavalue.value
					
					if value then
						return value.time
					end
				end
			end
		end
	end
end     
 
function p.getPropiedad(opciones, declaracion)
    local propiedad     = {}
    local tablaOrdenada = {}

    if opciones.propiedad == 'precisión' or opciones.propiedad == 'latitud' or opciones.propiedad == 'longitud'  then
        propiedad = 'P625' -- Si damos el valor latitud, longitud o precisión equivaldrá a dar p625
    else
        propiedad = opciones.propiedad -- En el resto de casos se lee lo dado
    end

    if not propiedad then -- Comprobamos si existe la propiedad dada y en caso contrario se devuelve un error
        return formatoError( 'property-param-not-provided' )
    end
 
    if declaracion then
        tablaOrdenada = declaracion
    elseif not p.getDeclaraciones(opciones.entityId) then
    	return formatoError( 'other entity' )
    elseif p.getDeclaraciones(opciones.entityId)[mw.ustring.upper(propiedad)] then 
    	tablaOrdenada = p.getDeclaraciones(opciones.entityId)[mw.ustring.upper(propiedad)]
    else
    	return ''
    end

	-- Evitar que pete cuando se haga el find en opciones['formatoTexto'] si vale nil
    if not opciones['formatoTexto'] then
    	opciones['formatoTexto'] = ''
    end

    --Dejar en su caso los valores de mayor rango
    if (opciones.rangoMayor == 'sí') then
        tablaOrdenada = filtrarDeclaracionPorRango(tablaOrdenada)
    end

    --Ordenar en su caso por fecha. Ver la función chronosort de :fr:Module:Wikidata/Récup
    if opciones.ordenar == 'por fecha' then
    	require('Módulo:Tablas').ordenar(tablaOrdenada, 
    		function(elemento1,elemento2) 
    			local fecha1 = valinQualif(elemento1, datequalifiers) or '' -- elemento1.qualifiers.P580[1].datavalue.value.time or ''
    			local fecha2 = valinQualif(elemento2, datequalifiers) or '' -- elemento2.qualifiers.P580[1].datavalue.value.time or ''
    			
    		    return fecha1 < fecha2
    	    end
    	 )
    end

    -- == Si solo se desea que devuelva un valor ==
    if opciones.uno == 'sí' then -- Para que devuelva el valor de índice 1
        tablaOrdenada = {tablaOrdenada[1]}
    end

-- == Creamos una tabla con los valores que devolverá ==
 
    local formatoDeclaraciones = {}
    local hayDeclaraciones
    
   
    if opciones.eliminaranexo or opciones.eliminar1 or opciones.eliminar2 or opciones.eliminar3 or opciones.eliminar4
    or opciones.eliminar5 or opciones.eliminar6 or opciones.eliminar7  or opciones.eliminar8 
    or opciones.eliminar9 or opciones.eliminar10 then
    	for indice, declaracion in pairs(tablaOrdenada) do
    		declaracionFormateada = formatoDeclaracion(declaracion, opciones)
    		if opciones.eliminar1 then comparador1=mw.ustring.find(declaracionFormateada,opciones.eliminar1) end
    		if opciones.eliminar2 then comparador2=mw.ustring.find(declaracionFormateada,opciones.eliminar2) end
    		if opciones.eliminar3 then comparador3=mw.ustring.find(declaracionFormateada,opciones.eliminar3) end
    		if opciones.eliminar4 then comparador4=mw.ustring.find(declaracionFormateada,opciones.eliminar4) end
    		if opciones.eliminar5 then comparador5=mw.ustring.find(declaracionFormateada,opciones.eliminar5) end
    		if opciones.eliminar6 then comparador6=mw.ustring.find(declaracionFormateada,opciones.eliminar6) end
    		if opciones.eliminar7 then comparador7=mw.ustring.find(declaracionFormateada,opciones.eliminar7) end
    		if opciones.eliminar8 then comparador8=mw.ustring.find(declaracionFormateada,opciones.eliminar8) end
    		if opciones.eliminar9 then comparador9=mw.ustring.find(declaracionFormateada,opciones.eliminar9) end
    		if opciones.eliminar10 then comparador10=mw.ustring.find(declaracionFormateada,opciones.eliminar10) end
    		if declaracionFormateada and declaracionFormateada ~= '' and comparador1==nil
    			and comparador2==nil and comparador3==nil and comparador4==nil and comparador4==nil
    			and comparador5==nil and comparador6==nil and comparador7==nil and comparador8==nil
    			and comparador9==nil and comparador10==nil then
    			if opciones.eliminaranexo then
    				if declaracionFormateada:sub(1,8)=='[[Anexo:' and string.find(declaracionFormateada,'|')==nil then
    					finenlace =string.find(declaracionFormateada,']')
    					declaracionFormateada= declaracionFormateada:sub(1,finenlace-1) ..'|'..declaracionFormateada:sub(9)
    				end
    			end
            	table.insert(formatoDeclaraciones, declaracionFormateada)
            	hayDeclaraciones = true
        	end    
    	end
	else	
		for indice, declaracion in pairs(tablaOrdenada) do
    		declaracionFormateada = formatoDeclaracion(declaracion, opciones)
    		if declaracionFormateada and declaracionFormateada ~= '' then
            	table.insert(formatoDeclaraciones, declaracionFormateada)
            	hayDeclaraciones = true
        	end    
    	end
	end    
    primera = true
    
    if not hayDeclaraciones then
        return
    end

 
    -- Aplicar el formato a la lista de valores según el tipo de lista de las
    -- opciones
    if opciones['lista'] == 'no ordenada' then
        return '<ul><li>' .. mw.text.listToText( formatoDeclaraciones, '</li><li>','</li><li>' ) .. '</li></ul>'
    elseif opciones['lista'] == 'ordenada' then
        return '<ol><li>' .. mw.text.listToText( formatoDeclaraciones, '</li><li>','</li><li>' ) .. '</li></ol>'            
    else
     	-- valores separados por coma o por el separador y la
      	-- conjunción de las opciones
       	local separador, conjuncion
        	
        if opciones['conjunción'] == 'null' then
            conjuncion = nil
        else
            conjuncion = opciones['conjunción'] 
        end
    
        if opciones['separador'] == 'null' then
            separador	= nil
        else
            separador = opciones['separador']
        end
        
        if (conjuncion == nil or conjuncion == 'y') and table.getn(formatoDeclaraciones) > 1 then
        	conjuncion = ' ' .. string.sub(marco:preprocess('{{y-e|{{desenlazar|' .. formatoDeclaraciones[#formatoDeclaraciones] .. '}}}}'), 1, 1) .. ' '
        elseif conjuncion ~= nil and conjuncion == 'o' and table.getn(formatoDeclaraciones) > 1 then
        	conjuncion = ' ' .. conjuncion .. ' '
        end
            
        return mw.text.listToText( formatoDeclaraciones, separador,conjuncion )
    end
end

-- Función que devuelve el valor de entidad.claims[idPropiedad][ocurrencia].mainsnak.datavalue.value.text
-- con entidad.claims[idPropiedad][ocurrencia].mainsnak.datavalue.value.language = 'es'

-- Útil para obtener valores de propiedades de tipo monolingualtext

function p.getPropiedadEnEspanyol(idEntidad, idPropiedad)
	-- Ver cs:Modul:Wikidata/item	formatEntityWithGender
	
	-- 
	local entidad =  mw.wikibase.getEntityObject(idEntidad)
	
	if not entidad then
		return
	end
	
	local elementoTabla = require('Módulo:Tablas').elemento
	local declaracion   = elementoTabla(entidad,'claims', idPropiedad)
	
	if not declaracion then
		return
	end
	
	local valor
	
	for k,v in pairs(declaracion) do
		valor = elementoTabla(v,'mainsnak', 'datavalue', 'value')
		
		if valor.language == 'es' then
			return valor.text
		end
	end
end

function p.categorizar(opciones, declaracion)
	-- Evitar que pete cuando se haga el find en opciones['formatoTexto'] si vale nil
    if not opciones['formatoTexto'] then
    	opciones['formatoTexto'] = ''
    end	
	
	local categoriaOpciones=opciones['categoría']	
	
	if not categoriaOpciones then
		return ''
	end

	opciones['enlace'] = 'no'

    -- Crear una tabla con los valores de la propiedad.	
	local valoresDeclaracion = {}
 
    if declaracion then
        valoresDeclaracion = declaracion
    elseif opciones.propiedad then
        local propiedad = {}
        if opciones.propiedad == 'precisión' or opciones.propiedad == 'latitud' or opciones.propiedad == 'longitud'  then
            propiedad = 'P625' -- Si damos el valor latitud, longitud o precisión equivaldrá a dar p625
        else
            propiedad = opciones.propiedad -- En el resto de casos se lee lo dado
        end
        
        if not p.getDeclaraciones(opciones.entityId) then
    	    return formatoError( 'other entity' )
        elseif p.getDeclaraciones(opciones.entityId)[mw.ustring.upper(propiedad)] then 
    	    valoresDeclaracion = p.getDeclaraciones(opciones.entityId)[mw.ustring.upper(propiedad)]
        else
    	    return ''
        end    	
    else
    	return ''
    end 
    
    -- == Si solo se desea que devuelva un valor ==
    --if opciones.uno == 'sí' then -- Para que devuelva el valor de índice 1
    --    return formatoDeclaracion( valoresDeclaracion[1],opciones)
    --end
    --if (opciones.rangoMayor == 'sí') then -- Para que devuelva los valores de mayor rango
     --   valoresDeclaracion = filtrarDeclaracionPorRango(valoresDeclaracion)
    --end    
 
--  Creamos una tabla con cada categoría a partir de cada valor de la declaración
    local categorias    = {}
    local hayCategorias
    
    if type(categoriaOpciones) == 'string' then
        local ModuloPaginas = require('Módulo:Páginas')
      
        for indice, valor in pairs(valoresDeclaracion) do
            valorFormateado = formatoDeclaracion(valor, opciones)
    	    if valorFormateado ~= '' then
    		    categoria = ModuloPaginas.existeCategoria(categoriaOpciones:gsub('$1',valorFormateado))
    		
                if categoria then
                    table.insert(categorias, categoria)
                    hayCategorias = true
                end
            end    
        end
    elseif type(categoriaOpciones) == 'table' then
        for indice, valor in pairs(valoresDeclaracion) do
            categoria = categoriaOpciones[valor.mainsnak.datavalue.value['numeric-id']]
            
            if categoria then
                table.insert(categorias, 'Categoría:' .. categoria)
                hayCategorias = true
            end
        end
    end
    
    if hayCategorias then
        return '[[' .. mw.text.listToText( categorias, ']][[',']][[') .. ']]'
    end
    
    return ''
end
 
 --[[ =========================================================================
        Función que comprueba si la página está enlazada a  Wikidata
        en caso de estarlo pasa el valor como a argumento a la función formatSnak()   
     ========================================================================= `-- ]]
 
function formatoDeclaracion( declaracion, opciones)
    if not declaracion.type or declaracion.type ~= 'statement' then -- Se comprueba que tiene valor de tipo y que este sea statement (declaración) lo cual pasa siempre que existe la propiedad
        return formatoError( 'unknown-claim-type' ) -- Si no se cumple devuelve error 
    end
    
    -- En el caso de que haya calificador se devuelve a la derecha del valor de la 
    -- declaración entre paréntesis.
    
    local calificativo = opciones.calificativo or opciones.calificador
 
    if calificativo and declaracion.qualifiers then
    	-- De momento los calificativos, normalmente años, no se enlazan
       local opcionesCalificativo = {['formatoTexto']='', enlace='no', ['formatoFecha']='año'} -- Pendiente
       
       local wValorCalificativo
       local wValorCalificativoFormateado
       
       if type(calificativo) == 'function' then
       	  -- Utilizar la función recibida sobre todos los calificativos
       	  wValorCalificativo           = declaracion.qualifiers
          wValorCalificativoFormateado = calificativo(wValorCalificativo, opcionesCalificativo)
       	elseif opciones.formatoCalificador and opciones.formatoCalificador == '()' then
			wValorCalificativo = declaracion.qualifiers[mw.ustring.upper(calificativo)]
	    	if wValorCalificativo and wValorCalificativo[1] then
	    		wValorCalificativoFormateado = p.formatoDato(wValorCalificativo[1], opcionesCalificativo)
	    	end
    	elseif opciones.formatoCalificador and table.getn(mw.text.split(opciones.formatoCalificador, '%.')) == 2 then
    		moduloFormatoCalificador = mw.text.split(opciones.formatoCalificador, '%.')
    		formateado = require ('Módulo:' .. moduloFormatoCalificador[1])
	        if not formateado then
	            return formatoError( 'value-module-not-found' )
	        end
	        fun = formateado[moduloFormatoCalificador[2]]
	        if not fun then
	            return formatoError( 'value-function-not-found' )
	        end
	        
	        if mw.ustring.find(opciones['formatoTexto'],'mayúscula', plain ) and 
		       (primera or (opciones['separador'] and opciones['separador'] ~= 'null') or 
		       	(opciones['lista'] and opciones['lista'] ~= '')) then
		      opciones['mayúscula'] = 'sí'
	              primera = false
		    end
		    
		    if mw.ustring.find(opciones['formatoTexto'],'cursivas', plain ) then
		    	opcionesEntidad.cursivas = 'sí'
		    end
	        
	        wValorCalificativoFormateado = fun( declaracion.qualifiers, opciones, marco)
	        --return require('Módulo:Tablas').tostring(declaracion)
	    else
       	  -- Utilizar el primer valor del calificativo de la propiedad recibida
       	  wValorCalificativo = declaracion.qualifiers[mw.ustring.upper(calificativo)]
       	  
       	  if wValorCalificativo and wValorCalificativo[1] then
            wValorCalificativoFormateado = p.formatoDato(wValorCalificativo[1], opcionesCalificativo)
	      end
	    end
		if opciones.separadorcalificador then separador = opciones.separadorcalificador else separador = ' ' end
    	if wValorCalificativoFormateado then
    		datoFormateado = p.formatoDato(declaracion.mainsnak, opciones)
    		return (datoFormateado and datoFormateado .. separador.. '&nbsp;<small>(' .. wValorCalificativoFormateado .. ')</small>') or nil
    	end	    
    end
 
    -- Si no hay calificativo.
    return p.formatoDato(seleccionDeclaracion(declaracion, opciones), opciones, declaracion.qualifiers)
end
 
 --[[ =========================================================================
        Función que comprueba el tipo de dato (snaktype)
        si es value pasa el valor como argumento a la función formatoValorDato()    
     ========================================================================= `-- ]] 
 
function p.formatoDato( dato, opciones, calificativos)
    
    if not dato or dato == '' then
        return ''
    end
    if dato.snaktype == 'somevalue' then
    	-- Fecha más temprana
    	if calificativos then
    		if calificativos['P1319'] and calificativos['P1319'][1] and
    	       calificativos['P1319'][1].datavalue and
    	       calificativos['P1319'][1].datavalue.type=='time' then
    	       	
                local opcionesFecha={['formatoFecha']=opciones['formatoFecha'],enlace=opciones.enlace}
        
                return 'post. ' .. require('Módulo:Wikidata/Fecha').FormateaFechaHora(calificativos['P1319'][1].datavalue.value, opcionesFecha)
            end
    	end
    	
    	-- Si no tiene un calificativo válido
        return avisos['somevalue'] -- Valor desconocido
    elseif dato.snaktype == 'novalue' then
        return avisos['novalue'] -- Sin valor
    elseif dato.snaktype == 'value' then
        return formatoValorDato( dato.datavalue, opciones, calificativos) -- Si tiene el tipo de dato se pasa el valor a la función formatDatavalue()
    else
        return formatoError( 'unknown-snak-type' ) -- Tipo de dato desconocido
    end
end
 
 --[[ =========================================================================
       Función que establece el tipo de formato en función del tipo de valor 
       (valorDato.type) y en caso de solicitarse un formato complemetario asocia
       el módulo donde se establece el formato y la función de este que lo establece    
     ========================================================================= `-- ]] 
 
function formatoValorDato( valorDato, opciones, calificativos)
	
	-- == Si se da el parámetro  valor-módulo y valor-función ==
	
	funcion = opciones['valor-función'] or opciones['value-function']
	if funcion and type(funcion) == 'function' then -- Uso desde LUA
	--  Ver un ejemplo en el módulo de Ficha de libro con el ISBN.
	    local opcionesEntidad = {}
	    
	    if mw.ustring.find(opciones['formatoTexto'],'mayúscula', plain ) and 
	       (primera or (opciones['separador'] and opciones['separador'] ~= 'null') or 
	       	(opciones['lista'] and opciones['lista'] ~= '')) then
	      opcionesEntidad['mayúscula'] = 'sí'
              primera = false
	    end	
	    opcionesEntidad.enlace         = opciones.enlace
	    opcionesEntidad.etiqueta       = opciones.etiqueta
	    opcionesEntidad['debeExistir'] = opciones['debeExistir']
	    
	    if mw.ustring.find(opciones['formatoTexto'],'cursivas', plain ) then
	    	opcionesEntidad.cursivas = 'sí'
	    end
	    
		return funcion(valorDato.value, opcionesEntidad, marco, calificativos)
    elseif (opciones['valor-módulo'] and opciones['valor-módulo'] ~= "" ) or (opciones['value-function'] and opciones['valor-function'] ~= "" ) then
        if not opciones['valor-módulo'] or not opciones['valor-función'] then
            return formatoError( 'unknown-value-module' )
        end
        local formateado = require ('Módulo:' .. opciones['valor-módulo'])
        if not formateado then
            return formatoError( 'value-module-not-found' )
        end
        local fun = formateado[opciones['valor-función']]
        if not fun then
            return formatoError( 'value-function-not-found' )
        end
        
        if mw.ustring.find(opciones['formatoTexto'],'mayúscula', plain ) and 
	       (primera or (opciones['separador'] and opciones['separador'] ~= 'null') or 
	       	(opciones['lista'] and opciones['lista'] ~= '')) then
	      opciones['mayúscula'] = 'sí'
              primera = false
	    end
	    
	    if mw.ustring.find(opciones['formatoTexto'],'cursivas', plain ) then
	    	opcionesEntidad.cursivas = 'sí'
	    end
        
        return fun( valorDato.value, opciones, marco)
    end
 
    -- == Formatos por defecto en función del tipo de valor ==
 
--          * Para tipo coordenadas cuando se da como valor de propiedad: latitud, longitud o precisión
 
    if opciones.propiedad == 'latitud' then 
        return valorDato.value['latitude']
    elseif opciones.propiedad == 'longitud' then
        return valorDato.value['longitude']
    elseif opciones.propiedad == 'precisión' then
        return valorDato.value['precision']
 
--           * Con el resto de valores en propiedad
 
    elseif valorDato.type == 'wikibase-entityid' then    -- Tipo: Número de entidad que puede ser un ítem o propiedad
	    local opcionesEntidad = {}
	    if mw.ustring.find(opciones['formatoTexto'],'mayúscula', plain ) and 
	       (primera or (opciones['separador'] and opciones['separador'] ~= 'null') or 
	       	(opciones['lista'] and opciones['lista'] ~= '')) then
	      opcionesEntidad['mayúscula'] = 'sí'
              primera = false
	    end
	    opcionesEntidad.enlace         = opciones.enlace
	    opcionesEntidad.etiqueta       = opciones.etiqueta
	    opcionesEntidad['debeExistir'] = opciones['debeExistir']
	    
	    if mw.ustring.find(opciones['formatoTexto'],'cursivas', plain ) then
	    	opcionesEntidad.cursivas = 'sí'
	    end
        return p.formatoIdEntidad( SelecionEntidadPorValor( valorDato.value ), opcionesEntidad)
    elseif valorDato.type == 'string' then               -- Tipo: Cadena de texto (string)
        return valorDato.value 
    elseif valorDato.type == 'url' then     --Tipo URL (dirección web)
	    return value.url
    elseif valorDato.type == 'time' then                 -- Tipo: Fecha/hora
        local opcionesFecha={['formatoFecha']=opciones['formatoFecha'],enlace=opciones.enlace}
       
        if mw.ustring.find(opciones['formatoTexto'] or '','mayúscula', plain ) and primera then
	        opcionesFecha['mayúscula']='sí'
        end
        
        return require('Módulo:Wikidata/Fecha').FormateaFechaHora(valorDato.value, opcionesFecha, calificativos)
    elseif valorDato.type == 'monolingualtext' then       -- Tipo: monoligüe
    	if valorDato.value then
            return valorDato.value.text
        else 
            return ''
        end
    elseif valorDato.type ==  'quantity' then            -- Tipo: Cantidad 
    	return require('Módulo:Wikidata/Formatos').formatoUnidad(valorDato, opciones)
    elseif  valorDato.value['latitude']  and valorDato.value['longitude'] then -- Tipo: Coordenadas
    	local globo = require('Módulo:Wikidata/Globos')[valorDato.value.globe]
 
--Concatenamos los valores de latitud y longitud dentro de la plantilla Coord
 
        if globo ~= 'earth' then
            return  marco:preprocess('{{coord|' .. valorDato.value['latitude'] .. '|' .. 
                   valorDato.value['longitude'] .. '|globe:' .. globo .. '_type:' .. opciones.tipo .. '|display=' .. 
                   opciones.display ..'|formato=' .. opciones.formato..'}}')
        else
        	return  marco:preprocess('{{coord|' .. valorDato.value['latitude'] .. '|' .. 
                   valorDato.value['longitude'] .. '|type:' .. opciones.tipo .. '|display=' .. 
                   opciones.display ..'|formato=' .. opciones.formato..'}}')
        end
 
    else
        return formatoError( 'unknown-datavalue-type' ) -- Si no es de ninguno de estos tipos devolverá error valor desconocido
    end
end
 
  --[[ =========================================================================
          Damos formato a los enlaces internos    
       ========================================================================= `-- ]]

-- Opciones:
--     - enlace:		Valores posibles 'sí' o 'no'
--     - mayúscula:		Valores posibles 'sí' o 'no'
--     - cursivas:		Valores posibles 'sí' o 'no'

function p.formatoIdEntidad(idEntidad, opciones)
    local enlace   = mw.wikibase.sitelink(idEntidad)
    local etiqueta = mw.wikibase.label(idEntidad)
	return require('Módulo:Wikidata/Formatos').enlazar(enlace, etiqueta, idEntidad, opciones)
end
 
 --[[ =========================================================================
        Función principal     
     ========================================================================= `-- ]]
 
function p.Wikidata( frame )
    marco = frame
    local args = frame.args
    local valorWikidata = p.getPropiedad( frame.args , nil)
 	local categorias = '';
 	local namespace = frame:preprocess('{{NAMESPACENUMBER}}');
 	
 	if (namespace == '0' and (not args.categorias or args.categorias ~= 'no') and 
 			args.propiedad and string.upper(args.propiedad) ~= 'P18' and 
 			string.upper(args.propiedad) ~= 'P41' and string.upper(args.propiedad) ~= 'P94'
 			and string.upper(args.propiedad) ~= 'P109' and string.upper(args.propiedad) ~= 'P94'
 			and string.upper(args.propiedad) ~= 'P154') then
	 	if valorWikidata ~= '' and args.valor and args.valor ~= '' then
	 		categorias = '[[Categoría:Wikipedia:Artículos con datos locales]]'
	 	elseif valorWikidata and valorWikidata == '' and args.valor and args.valor ~= '' and 
	 		(not args.calificador or args.calificador == '') and 
	 		(not args.dato or args.dato == '' or args.dato ~= 'fuente')then
	 		categorias = '[[Categoría:Wikipedia:Artículos con datos por trasladar a Wikidata]]'
	 	end
	end
 
    if args.prioridad == 'sí' and valorWikidata  ~= '' then -- Si se da el valor sí a prioridad tendrá preferencia el valor de Wikidata 
    	if args.importar and args.importar == 'no' and args.valor and args.valor ~= '' then 
    		return args.valor .. categorias
    	elseif valorWikidata then
        	return valorWikidata .. categorias -- valor que sustituye al valor de Wikidata parámetro 2
        else
        	return categorias
        end
    elseif args.valor and args.valor ~= '' then 
         return args.valor .. categorias
    elseif args.importar and args.importar == 'no' then 
         return ''
    elseif valorWikidata then -- Si el valor es nil salta una excepcion al concatenar
        return valorWikidata .. categorias
    else
    	return ''
  end  
end
 
return p