Diferencia entre revisiones de «Módulo:Wikidata»

Si se usa "()" como formato de calificador el calificador se tiene que mostrar concatenado al dato entre paréntesis y no afecta a la visualización del dato en sí. Sin esa condición no muestra los protagonistas desde Wikidata en ficha de película.
m 485 revisiones importadas
 
(No se muestran 102 ediciones intermedias de 17 usuarios)
Línea 1: Línea 1:
--[[*********************************************************************************
--[[*********************************************************************************
    * Nombre: Módulo:Wikidata
* Nombre: Módulo:Wikidata
    *
*
    * Descripción: Este módulo devuelve el valor o valores con o sin formato específico
* Descripción: Este módulo devuelve el valor o valores con o sin formato
    *             a una propiedad de Wikidata.  
* específico a una propiedad de Wikidata.
    *
*
    * Fecha última revisión: 6 de septiembre de 2014.
* Fecha última revisión: 30 de junio de 2021.
    *
*
    * Estado: En uso.  
* Estado: En uso.
    *
*
    *********************************************************************************`-- ]]
*********************************************************************************`-- ]]
local p = {}
local p = {}
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
local es = mw.language.new('es')
local es = mw.language.new('es')
local primera = true
local primera = true
local marco
--local marco Ojo. marco no debe definirse como local pues si se hace así puede fallar.
  --[[ =========================================================================
  --[[ =========================================================================
            Mensajes de error
Mensajes de error
      ========================================================================= `-- ]]
  ========================================================================= `-- ]]
 
local avisos = {
local avisos = mw.loadData('Módulo:Wikidata/mensajes')
    ["errores"] = {
 
        ["property-param-not-provided"] = "Parámetro de la propiedad no proporcionado.",
-- Módulos y funciones utilizadas
        ["entity-not-found"] = "Entrada no encontrada.",
local elementoTabla = require('Módulo:Tablas').elemento
        ["unknown-claim-type"] = "Tipo de notificación desconocida.",
--
        ["unknown-snak-type"] = "Tipo de dato desconocido.",
-- Módulos en los que están definidos los tipos de datos más habituales si son
        ["unknown-datavalue-type"] = "Formato de dato desconocido.",
-- diferentes de Wikidata/Formatos
        ["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.",
local modulosTipos = mw.loadData('Módulo:Wikidata/modulosTipos')
        ["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.",
local modulosTiposComplejos = {
        ["other entity"] = "Enlaces a elementos diferentes desactivado."
['nacionalidad'] = 'Módulo:Wikidata/Formatos país',
    },
    ["somevalue"] = "''valor desconocido''",
    ["novalue"] = ""
}
}
  --[[ =========================================================================
  --[[ =========================================================================
      Función para pasar el frame cuando se usa en otros módulos.    
  Función para pasar el frame cuando se usa en otros módulos.
    ========================================================================= `-- ]]
========================================================================= `-- ]]
function p:setFrame(frame)
function p:setFrame(frame)
marco = frame
marco = frame
end
end
  --[[ =========================================================================
  --[[ =========================================================================
      Función para identificar el ítem correspondiente a la página o otro dado.
  Función para identificar el ítem correspondiente a la página o otro dado.
              Esto último aún no funciona.    
  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


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


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


    if not propiedad then -- Comprobamos si existe la propiedad dada y en caso contrario se devuelve un error
if not propiedad then -- Comprobamos si existe la propiedad dada y en caso contrario se devuelve un error
        return formatoError( 'property-param-not-provided' )
return formatoError( 'property-param-not-provided' )
    end
end
local tablaOrdenada
    if declaracion then
if declaracion then
        tablaOrdenada = declaracion
tablaOrdenada = declaracion
    elseif not p.getDeclaraciones(opciones.entityId) then
elseif mw.wikibase.isValidEntityId(tostring(opciones.entityId)) and mw.wikibase.isValidEntityId(tostring(propiedad)) then
    return formatoError( 'other entity' )
tablaOrdenada = mw.wikibase.getAllStatements( opciones.entityId, mw.ustring.upper(propiedad) )
    elseif p.getDeclaraciones(opciones.entityId)[mw.ustring.upper(propiedad)] then  
if not tablaOrdenada[1] then return '' end
    tablaOrdenada = p.getDeclaraciones(opciones.entityId)[mw.ustring.upper(propiedad)]
else
    else
return ''
    return ''
end
    end
-- Función que separa la cadena de texto 'inputstr' utilizando un separador 'sep'
function split(inputstr, sep)
sep=sep or '%s'
local t={}
for field,s in string.gmatch(inputstr, "([^"..sep.."]*)("..sep.."?)") do
table.insert(t,field) 
if s=="" then  
return t
end
end
end
tablaOrdenada = p.filtroDesconocidos(tablaOrdenada)
-- Aplicar filtro de calificador
if (opciones.filtroCalificador ~= nil and opciones.filtroCalificador ~= '') then
local opts = split(opciones.filtroCalificador, ';')
local negative = false
if (#opts > 2) then
if (opts[3]=='n') then
negative = true
elseif (opts[3]=='p') then
negative = false
end
end
tablaOrdenada = p.filtroCalificadores(tablaOrdenada, opts[1], split(opts[2], ','), negative)
end
-- Aplicar filtro de valor
if (opciones.filtroValor ~= nil and opciones.filtroValor ~= '') then
local opts = split(opciones.filtroValor, ';')
local negative = false
if (#opts > 1) then
if (opts[2]=='n') then
negative = true
elseif (opts[2]=='p') then
negative = false
end
end
tablaOrdenada = p.filtroValores(tablaOrdenada, split(opts[1], ','), negative)
end
-- Aplicar función de formato
local modulo, funcion
funcion = opciones['valor-función'] or opciones['value-function'] or opciones['funcion']
if funcion then
modulo = modulosTiposComplejos[funcion]
if modulo then
return require(modulo)[funcion](tablaOrdenada, opciones)
end
end


-- Evitar que pete cuando se haga el find en opciones['formatoTexto'] si vale nil
-- Evitar que pete cuando se haga el find en opciones['formatoTexto'] si vale nil
    if not opciones['formatoTexto'] then
if not opciones['formatoTexto'] then
    opciones['formatoTexto'] = ''
opciones['formatoTexto'] = ''
    end
end
 
-- Aplicar filtro de mayor rango
if (opciones.rangoMayor == 'sí') then
tablaOrdenada = p.filtrarDeclaracionPorRango(tablaOrdenada)
end


    --Dejar en su caso los valores de mayor rango
-- Ordenarsegún el calificador "orden dentro de la serie"
    if (opciones.rangoMayor == 'sí') then
if opciones.ordenar == 'sí' then
        tablaOrdenada = filtrarDeclaracionPorRango(tablaOrdenada)
require('Módulo:Tablas').ordenar(tablaOrdenada,
    end
function(elemento1,elemento2)
local orden1 = valinQualif(elemento1, { 'P1545' }) or '' -- elemento1.qualifiers.P1545[1].datavalue.value or ''
local orden2 = valinQualif(elemento2, { 'P1545' }) or '' -- elemento2.qualifiers.P1545[1].datavalue.value or ''
return orden1 < orden2
end
)
end


    --Ordenar en su caso por fecha. Ver la función chronosort de :fr:Module:Wikidata/Récup
--Ordenar según la fecha. [Véase la función chronosort de :fr:Module:Wikidata/Récup]
    if opciones.ordenar == 'por fecha' then
if opciones.ordenar == 'por fecha' then
    require('Módulo:Tablas').ordenar(tablaOrdenada,  
require('Módulo:Tablas').ordenar(tablaOrdenada,
    function(elemento1,elemento2)  
function(elemento1,elemento2)
    local fecha1 = valinQualif(elemento1, datequalifiers) or '' -- elemento1.qualifiers.P580[1].datavalue.value.time or ''
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 ''
local fecha2 = valinQualif(elemento2, datequalifiers) or '' -- elemento2.qualifiers.P580[1].datavalue.value.time or ''
   
        return fecha1 < fecha2
return fecha1 < fecha2
        end
end
    )
)
    end
end
-- Si después de todo no queda nada en la tabla retornar
if not tablaOrdenada[1] then
return
end


    -- == Si solo se desea que devuelva un valor ==
-- == Si solo se desea que devuelva un valor ==
    if opciones.uno == 'sí' then -- Para que devuelva el valor de índice 1
-- Pendiente eliminar el parámetro y sustituirlo por un nuevo valor del parámetro lista=no que haría lo mismo que opciones.uno = sí
        tablaOrdenada = {tablaOrdenada[1]}
if opciones.uno == 'sí' then -- Para que devuelva el valor de índice 1
    end
tablaOrdenada = {tablaOrdenada[1]}
elseif opciones.uno == 'último' then -- Para que devuelva la última entrada de la tabla
tablaOrdenada = {tablaOrdenada[#tablaOrdenada]}
end


-- == Creamos una tabla con los valores que devolverá ==
-- == 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


local formatoDeclaraciones = {}
    -- Aplicar el formato a la lista de valores según el tipo de lista de las
local hayDeclaraciones
    -- opciones
    if opciones['lista'] == 'no ordenada' then
for indice, declaracion in pairs(tablaOrdenada) do
        return '<ul><li>' .. mw.text.listToText( formatoDeclaraciones, '</li><li>','</li><li>' ) .. '</li></ul>'
  declaracionFormateada = p.formatoDeclaracion(declaracion, opciones)
    elseif opciones['lista'] == 'ordenada' then
  if declaracionFormateada and declaracionFormateada ~= '' then
        return '<ol><li>' .. mw.text.listToText( formatoDeclaraciones, '</li><li>','</li><li>' ) .. '</li></ol>'           
  table.insert(formatoDeclaraciones, declaracionFormateada)
    else
  hayDeclaraciones = true
    -- valores separados por coma o por el separador y la
  end
      -- conjunción de las opciones
  end
      local separador, conjuncion
 
       
primera = true
        if opciones['conjunción'] == 'null' then
            conjuncion = nil
if not hayDeclaraciones then
        else
return
            conjuncion = opciones['conjunción']
end
        end
 
   
-- Aplicar el formato a la lista de valores según el tipo de lista de las
        if opciones['separador'] == 'null' then
-- opciones
            separador = nil
        else
return p.formatoLista(formatoDeclaraciones, opciones)
            separador = opciones['separador']
end
        end
 
       
-- Función que sirve para comprobar si una entidad tiene una propiedad con un
        if (conjuncion == nil or conjuncion == 'y') and table.getn(formatoDeclaraciones) > 1 then
-- valor específico
        conjuncion = ' ' .. string.sub(marco:preprocess('{{y-e|{{desenlazar|' .. formatoDeclaraciones[#formatoDeclaraciones] .. '}}}}'), 1, 1) .. ' '
-- Parámetros:
        elseif conjuncion ~= nil and conjuncion == 'o' and table.getn(formatoDeclaraciones) > 1 then
--  · entidad: tabla de la entidad de Wikidata
        conjuncion = ' ' .. conjuncion .. ' '
--  · propiedad: identificador de Wikidata para la propiedad
        end
--  · valor: valor de la propiedad en Wikidata
           
function p.tieneValorPropiedad(entidad, propiedad, valor)
        return mw.text.listToText( formatoDeclaraciones, separador,conjuncion )
    end
if entidad and entidad.claims and entidad.claims[propiedad] then
local mainsnak
for key,value in ipairs(entidad.claims[propiedad]) do
if value and value.mainsnak then
mainsnak = value.mainsnak
if mainsnak.datatype == 'wikibase-item' and
mainsnak.snaktype == 'value' and
mainsnak.datavalue.value.id == valor then
return true
end
end
end
end
return false
end
 
-- Función que sirve para devolver la leyenda (P2096) de una imagen (P18) en Wikidata en un determinado idioma
-- La función se llama así: {{#invoke:Wikidata |getLeyendaImagen | <PARÁMETRO> | lang=<ISO-639code> |id=<QID>}}
-- Devuelve PARÁMETRO, a menos que sea igual a "FETCH_WIKIDATA", del objeto QID (llamada que consume recursos)
-- Si se omite QID o está vacio, se utiliza el artículo actual (llamada que NO consume recursos)
-- Si se omite lang se utiliza por defecto el idioma local de la wiki, en caso contrario el idioma del código ISO-639
-- ISO-639 está documentado aquí: https://docs.oracle.com/cd/E13214_01/wli/docs92/xref/xqisocodes.html#wp1252447
-- El ranking es: 'preferred' > 'normal' y devuelve la etiqueta de la primera imágen con ranking 'preferred'
-- O la etiqueta de la primera imagen with ranking 'normal' si no hay ningún 'preferred'
-- Ranks: https://www.mediawiki.org/wiki/Extension:Wikibase_Client/Lua
 
p.getLeyendaImagen = function(frame)
-- busca un un elemento concreto en Wikidata (QID), en caso contrario que sea nil
local id = frame.args.id
 
if id and (#id == 0) then
id = nil
end
 
-- busca el parámetro del idioma que debería contender un código ISO-639 de dos dígitos
-- si no se declara, toma por defecto el idioma local de la wiki (es)
local lang = frame.args.lang
if (not lang) or (#lang < 2) then
lang = mw.language.getContentLanguage().code
end
 
-- el primer parámetro sin nombrar es el parámetro local, si se declara
local input_parm = mw.text.trim(frame.args[1] or "")
if input_parm == "FETCH_WIKIDATA" or input_parm == "" or input_parm == nil then
local ent = mw.wikibase.getEntityObject(id)
local imgs
if ent and ent.claims then
imgs = ent.claims.P18
end
local imglbl
if imgs then
-- busca una imagen con ranking 'preferred'
for k1, v1 in pairs(imgs) do
if v1.rank == "preferred" and v1.qualifiers and v1.qualifiers.P2096 then
local imglbls = v1.qualifiers.P2096
for k2, v2 in pairs(imglbls) do
if v2.datavalue.value.language == lang then
imglbl = v2.datavalue.value.text
break
end
end
end
end
-- si no hay ninguna, busca una con ranking 'normal'
if (not imglbl) then
for k1, v1 in pairs(imgs) do
if v1.rank == "normal" and v1.qualifiers and v1.qualifiers.P2096 then
local imglbls = v1.qualifiers.P2096
for k2, v2 in pairs(imglbls) do
if v2.datavalue.value.language == lang then
imglbl = v2.datavalue.value.text
break
end
end
end
end
end
end
return imglbl
else
return input_parm
end
end
end


Línea 347: Línea 455:
-- Ver cs:Modul:Wikidata/item formatEntityWithGender
-- Ver cs:Modul:Wikidata/item formatEntityWithGender
--  
--
local entidad =  mw.wikibase.getEntityObject(idEntidad)
local entidad =  mw.wikibase.getEntityObject(idEntidad)
Línea 354: Línea 462:
end
end
local elementoTabla = require('Módulo:Tablas').elemento
local declaracion  = elementoTabla(entidad,'claims', idPropiedad)
local declaracion  = elementoTabla(entidad,'claims', idPropiedad)
Línea 366: Línea 473:
valor = elementoTabla(v,'mainsnak', 'datavalue', 'value')
valor = elementoTabla(v,'mainsnak', 'datavalue', 'value')
if valor.language == 'es' then
if valor and valor.language == 'es' then
return valor.text
return valor.text
end
end
end
end
end
-- devuelve el ID de la página en Wikidata (Q...), o nada si la página no está conectada a Wikidata
function p.pageId(frame)
local entity = mw.wikibase.getEntityObject()
if not entity then return nil else return entity.id end
end
end


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


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


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


function p.formatoIdEntidad(idEntidad, opciones)
function p.formatoIdEntidad(idEntidad, opciones)
    local enlace  = mw.wikibase.sitelink(idEntidad)
local enlace  = mw.wikibase.sitelink(idEntidad)
    local etiqueta = mw.wikibase.label(idEntidad)
local etiqueta = mw.wikibase.label(idEntidad)
return require('Módulo:Wikidata/Formatos').enlazar(enlace, etiqueta, idEntidad, opciones)
return require('Módulo:Wikidata/Formatos').enlazar(enlace, etiqueta, idEntidad, opciones)
end
end
 
  --[[ =========================================================================
  --[[ =========================================================================
        Función principal    
Función principal
    ========================================================================= `-- ]]
========================================================================= `-- ]]
 
function p.Wikidata( frame )
function p.Wikidata( frame )
     marco = frame
 
    local args = frame.args
    TIPOLLP="" --Variable global para identificar los casos de latitud, longitud o precisión
     local valorWikidata = p.getPropiedad( frame.args , nil)
      
marco = frame
local args = frame.args
if args.valor == 'no' then
return
end
 
local parentArgs = frame:getParent().args
 
 
-- Copiar los argumentos
local argumentos = {}
for k, v in pairs(args) do
argumentos[k] = v
end
for k, v in pairs(parentArgs) do
if not argumentos[k] then
argumentos[k] = v
end
end
 
     if argumentos[1]=='longitud' or argumentos[1]=='latitud' or argumentos[1]=='precisión' then
      TIPOLLP=argumentos[1]
      marco.args[argumentos[1]]='P625'
    end
 
--if true then return require('Módulo:Tablas').tostring(argumentos) end
-- No generar el valor de Wikidata si se ha facilitado un valor local y
-- el valor local es prioritario.
local valorWikidata;
if (args.prioridad ~= 'sí' or (args.importar and args.importar == 'no')) and args.valor and args.valor ~= '' then
valorWikidata = nil;
else
if not mw.wikibase.isValidEntityId(tostring(argumentos.entityId)) then
argumentos.entityId = mw.wikibase.getEntityIdForCurrentPage() or nil
end
valorWikidata = p.getPropiedad(argumentos, nil);
end
  local categorias = '';
  local categorias = '';
  local namespace = frame:preprocess('{{NAMESPACENUMBER}}');
  local namespace = frame:preprocess('{{NAMESPACENUMBER}}');
 
 
  if (namespace == '0' and (not args.categorias or args.categorias ~= 'no') and  
  if (namespace == '0' and (not args.categorias or args.categorias ~= 'no') and
  args.propiedad and string.upper(args.propiedad) ~= 'P18' and
  args.propiedad and string.upper(args.propiedad) ~= 'P18' -- P18: imagen de Commons
  string.upper(args.propiedad) ~= 'P41' and string.upper(args.propiedad) ~= 'P94'
  and string.upper(args.propiedad) ~= 'P41' -- P41: imagen de la bandera
  and string.upper(args.propiedad) ~= 'P109' and string.upper(args.propiedad) ~= 'P94'
and string.upper(args.propiedad) ~= 'P94' -- P94: imagen del escudo de armas
  and string.upper(args.propiedad) ~= 'P154') then
  and string.upper(args.propiedad) ~= 'P109' -- P109: firma de persona
if valorWikidata ~= '' and args.valor and args.valor ~= '' then
  and string.upper(args.propiedad) ~= 'P154') then -- P154: logotipo
if valorWikidata and valorWikidata ~= '' and args.valor and args.valor ~= '' then
categorias = '[[Categoría:Wikipedia:Artículos con datos locales]]'
categorias = '[[Categoría:Wikipedia:Artículos con datos locales]]'
elseif valorWikidata and valorWikidata == '' and args.valor and args.valor ~= '' and  
elseif valorWikidata and valorWikidata == '' and args.valor and args.valor ~= '' and
(not args.calificador or args.calificador == '') and  
(not args.calificador or args.calificador == '') and
(not args.dato or args.dato == '' or args.dato ~= 'fuente')then
(not args.dato or args.dato == '' or args.dato ~= 'fuente') then
categorias = '[[Categoría:Wikipedia:Artículos con datos por trasladar a Wikidata]]'
categorias = '[[Categoría:Wikipedia:Artículos con datos por trasladar a Wikidata]]'
end
end
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.prioridad == 'sí' and valorWikidata 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  
if args.importar and args.importar == 'no' and args.valor and args.valor ~= '' then
    return args.valor .. categorias
return args.valor .. categorias
    elseif valorWikidata then
elseif valorWikidata then
        return valorWikidata .. categorias -- valor que sustituye al valor de Wikidata parámetro 2
return valorWikidata .. categorias -- valor que sustituye al valor de Wikidata parámetro 2
        else
else
        return categorias
return categorias
        end
end
    elseif args.valor and args.valor ~= '' then  
elseif args.valor and args.valor ~= '' then
        return args.valor .. categorias
return args.valor .. categorias
    elseif args.importar and args.importar == 'no' then  
elseif args.importar and args.importar == 'no' then
        return ''
return ''
    elseif valorWikidata then -- Si el valor es nil salta una excepcion al concatenar
elseif valorWikidata then -- Si el valor es nil salta una excepcion al concatenar
        return valorWikidata .. categorias
return valorWikidata .. categorias
    else
else
    return ''
return ''
   end   
   end  
end
 
function obtenerFuncion(funcion, nombreModulo)
if not funcion then
return
elseif type(funcion) == 'function' then -- Uso desde LUA
return funcion
elseif funcion == '' or not nombreModulo or nombreModulo == '' then
return
else -- Uso desde una plantilla
local modulo
if not nombreModulo or nombreModulo == '' or nombreModulo == 'Wikidata/Formatos' then
modulo = require(modulosTipos[funcion] or 'Módulo:Wikidata/Formatos')
else
modulo = require ('Módulo:' .. nombreModulo)
end
  if not modulo then
  return nil, formatoError( 'value-module-not-found' )
elseif not modulo[funcion] then
  return nil, formatoError( 'value-function-not-found' )
else
  return modulo[funcion]
  end
end
end
 
function p.addLinkback(valorPropiedad, idEntidad, idPropiedad)
local lidEntidad
if valorPropiedad and idPropiedad then
lidEntidad= (idEntidad ~='' and idEntidad) or mw.wikibase.getEntityIdForCurrentPage()
end
 
if lidEntidad then
return valorPropiedad .. '<span class=\"wikidata-link lapiz noprint\"> [[Archivo:Blue_pencil.svg|Ver y modificar los datos en Wikidata|10px|baseline|alt=Ver y modificar los datos en Wikidata|enlace=https://www.wikidata.org/wiki/' .. lidEntidad .. '?uselang=es#' .. idPropiedad ..
']]</span>'
else
return valorPropiedad
end
end
 
function p.formatoLista(tabla, opciones)
if not tabla or not tabla[1] then
return
end
local tipo_lista = opciones.lista
local lapiz
if opciones.linkback == 'sí' and opciones.entityId and opciones.propiedad then
lapiz = '<span class=\"wikidata-link lapiz noprint\"> [[Archivo:Blue_pencil.svg|Ver y modificar los datos en Wikidata|10px|baseline|alt=Ver y modificar los datos en Wikidata|enlace=https://www.wikidata.org/wiki/' .. opciones.entityId .. '?uselang=es#' .. opciones.propiedad ..
']]</span>'
else
lapiz = ''
end
if not tabla[2] then
-- Si la tabla solo tiene un elemento devolverlo
return tabla[1] .. lapiz
end
if tipo_lista == 'no ordenada' or tipo_lista == 'ordenada' or tipo_lista == 'nobullet' then
local lista = mw.text.listToText( tabla, '</li><li>', '</li><li>' )
if tipo_lista == 'no ordenada' then
return '<ul><li>' .. lista .. lapiz .. '</li></ul>'
elseif tipo_lista == 'ordenada' then
return '<ol><li>' .. lista .. lapiz .. '</li></ol>'
else
return '<ul style="list-style-type:none;list-style-image:none;margin-left:0;padding-left:0"><li>' .. lista .. lapiz .. '</li></ul>'
end
else
local separadores = {
[''] = '',
[','] = ', ',
['null'] = ', ',
['no'] = ''
}
local conjunciones = {
[''] = '',
['y'] = ' y ',
['o'] = ' o ',
['null'] = ' y ',
['no'] = ''
}
local separador = opciones.separador
local conjuncion = opciones['conjunción']
if not separador then
separador = ', '
else
separador = separadores[separador] or separador
end
if not conjuncion then
conjuncion = ' y '
else
conjuncion = conjunciones[conjuncion] or conjuncion
end
if conjuncion == ' y ' and marco and tabla[2] then
conjuncion = ' ' .. marco:preprocess('{{y-e|{{Desvincular|' .. tabla[#tabla] .. '}}|sin texto}}') .. ' '
end
return mw.text.listToText( tabla, separador, conjuncion ) .. lapiz
end
end
 
-- Funciones existentes en otros módulos
function p.obtenerEtiquetaWikidata(entidad, fallback)
if not entidad then entidad = fallback end
if entidad and entidad.labels and entidad.labels.es then
return entidad.labels.es.value
end
end
 
function p.obtenerImagenWikidata(entidad, propiedad)
local imagen, valorImagen, piesDeImagen, k, pieDeImagen
if not entidad then
return
end
--  Obtener la primera imagen en Wikidata de la persona
local imagen = elementoTabla(entidad, 'claims', propiedad, 1)
--[[
-- Obtener el objeto de imagen, ya sea la primera, la última (WIP) o por fecha (WIP)
local imagen = (function()
local ImagenObj = elementoTabla(entidad, 'claims', idPropiedad)
if opciones.ordenar == 'por fecha' then
--
end
 
return elementoTabla(ImagenObj, 1)
end)()
--]]
if not imagen then
return
end
valorImagen = elementoTabla(imagen, 'mainsnak', 'datavalue', 'value')
piesDeImagen =  elementoTabla(imagen, 'qualifiers', 'P2096')
-- Encontrar el pie en español
if piesDeImagen then
for k,pieDeImagen in pairs(piesDeImagen) do
if pieDeImagen.datavalue.value.language == 'es' then
return valorImagen, pieDeImagen.datavalue.value.text
end
end
end
-- Si no hay pie de imagen en español comprueba si hay fecha especificada para la imagen
piesDeImagen = elementoTabla(imagen, 'qualifiers', 'P585')
if piesDeImagen and piesDeImagen[1] then
return valorImagen, 'En ' .. require('Módulo:Wikidata/Fecha').FormateaFechaHora(piesDeImagen[1].datavalue.value, {['formatoFecha']='año',['enlace']='no'})
end
-- Sin pie de imagen en español
return valorImagen
end
 
function p.propiedad(entidad, idPropiedad, opciones)
if entidad and entidad.claims and entidad.claims[idPropiedad] then
if not opciones then
opciones = {['linkback']='sí'}
end
--[[
local ValorPosicional = (function()
if opciones['valor_posicional'] == 'último' then return -1 end
if type(opciones['valor_posicional']) == 'number' then return opciones['valor_posicional'] end
return 1
end)()
 
local ValorPosicionalCalif =(function()
if opciones['valor_posicional_calif'] == 'último' then return -1 end
if type(opciones['valor_posicional_calif']) == 'number' then return opciones['valor_posicional_calif'] end
return 1
end)()
local Calificador = opciones['calificador']
 
local Obj = (function()
local Obj = (function()
local Obj = elementoTabla(entidad, 'claims', idPropiedad)
if ValorPosicional == -1 then return elementoTabla(Obj, #Obj) end
return elementoTabla(Obj, ValorPosicional)
end)()
 
if Calificador then
Obj = (function()
local Obj = elementoTabla(Obj, 'qualifiers', Calificador)
if ValorPosicionalCalif == -1 then return elementoTabla(Obj, #Obj) end
return elementoTabla(Obj, ValorPosicionalCalif)
end)()
end
return Obj
end)()
Tipo = elementoTabla(Obj, 'datavalue', 'type')
-- Devolver el ID de la entidad, para propiedades de entidad
if opciones['formato'] == 'entidadID' then
return elementoTabla(Obj, 'datavalue', 'value', 'id')
end
-- Preparar para devolver el archivo más reciente en la propiedad. Buscar cómo hacerlo con los calificadores
if opciones['formato'] == 'archivo' then
if Calificador then return elementoTabla(Obj, 'datavalue', 'value') end
if not opciones['uno'] then opciones['uno'] = 'último' end
opciones['ordenar'] = 'por fecha'
end
 
-- Obtener la propiedad como cadena sin formato
if opciones['formato'] == 'cadena' then
opciones['linkback'] = 'no'
if Tipo == 'string' then
return elementoTabla(Obj, 'datavalue', 'value')
end
end
 
-- Devolver una cadena numérica correctamente formateada
if opciones['formato'] == 'número' then
if Tipo == 'quantity' then
return formatoNumero(elementoTabla(Obj, 'datavalue', 'value', 'amount'))
end
end
 
-- Devolver una cadena numérica con su unidad
if opciones['formato'] == 'unidad' then
if elementoTabla(entidad, 'claims', idPropiedad, 2, 'mainsnak', 'datavalue') then
return formatoNumero(elementoTabla(entidad, 'claims', idPropiedad, 1, 'mainsnak', 'datavalue', 'value', 'amount')) .. '&nbsp;-&nbsp;' .. numeroUnidad(elementoTabla(entidad, 'claims', idPropiedad, 2, 'mainsnak', 'datavalue'), opciones)
else
return numeroUnidad(elementoTabla(entidad, 'claims', idPropiedad, 1, 'mainsnak', 'datavalue'), opciones)
end
end
--]]
opciones.entityId  = entidad.id
opciones.propiedad = idPropiedad
return p.getPropiedad(opciones, entidad.claims[idPropiedad])
end
end
 
function p.esUnValor(entidad, idPropiedad, idaBuscar)
if not entidad or not idPropiedad then
return false
end
local declaracion = elementoTabla(entidad, 'claims', idPropiedad)
local idBuscado
if not declaracion then
return false
end
 
for k,v in pairs(declaracion) do
idBuscado = elementoTabla(v,'mainsnak','datavalue','value','id')
if idBuscado == idaBuscar then
return true
end
end
return false
end
 
-- Obtener el objeto mw.language, para usar sus funciones en otros módulos
function p.language()
return es
end
end
 
return p
return p