Vizualizare sursă pentru „Modul:LocationAndCountry”

-- will display a wikidata property representing a location, followed by a comma and the name of the country, both with wikilinks
-- the first argument specifies the parameter to be displayed
-- the second argument specifies the entity ID
-- the third argument specifies a timestamp showing the moment in time for which the country is to be identified
-- the fourth argument specifies the maximum number of values to be processed (default 1)
-- the fifth argument specifies the separator to use when displaying multiple values
local getArgs = require('Modul:Arguments').getArgs
local Wikidata = require('Modul:Wikidata')
local lacData = mw.loadData('Modul:LocationAndCountry/data')
local TableTools = require('Modul:TableTools')
local GregorianDate = require('Modul:GregorianDate')
local DateUtils = require('Modul:DateUtils')
local Set = require('Modul:Set')
local illWd = require('Modul:Ill-wd').fromArgs
local Transliteration = require('Modul:Transliteration')
local getValueByTimestamp = require('Modul:TimestampedTable').getValueByTimestamp
local p = {}

local function getClaimsForParam(entity, param)
	local claims = nil
	local workingEntityId = nil
	if type(entity) == 'table' then
		workingEntityId = entity.id
		claims = entity:getBestStatements(param)
	else
		workingEntityId = entity
		if not workingEntityId then workingEntityId = mw.wikibase.getEntityIdForCurrentPage() end
		if type(entity) == 'number' then workingEntityId = 'Q' .. tostring(entity) end
		if workingEntityId == nil then return '' end
		claims = mw.wikibase.getBestStatements(workingEntityId, param)
	end
	return claims, workingEntityId
end

local function getTimestamp(timestamp, workingEntityId)
	local ts = nil
	if timestamp then
		if type(timestamp) == 'string' and mw.ustring.gmatch(timestamp, 'P%d+') then
			local wdDates = Wikidata.findDateValues(timestamp, workingEntityId)
			if wdDates then for _,eachWdDate in ipairs(wdDates) do
				if Wikidata.isClaimTrue(eachWdDate.claim) and Wikidata.hasValueSnak(eachWdDate.claim) then
					ts = GregorianDate.convertToGregorianIfInInterval(eachWdDate)
					break
				end
			end end
		end
		if ts == nil and type(timestamp) == 'string' and mw.ustring.match(timestamp, '^%d+') then
			ts = DateUtils.parseYear(timestamp)
		elseif ts == nil and type(timestamp) == 'table' and timestamp.year then
			ts = timestamp
		end
	end
	return ts
end

local function getUatsAndCountryFromQuals(claim)
	if not Wikidata.isClaimTrue(claim) or not claim.qualifiers then return nil end
	local country = nil
	local uats = {}
	if claim.qualifiers['P17'] then for _,eachCountryQual in ipairs(claim.qualifiers['P17']) do
		if Wikidata.isValueSnak(eachCountryQual) then
			country = eachCountryQual.datavalue.value.id
			break
		end
	end end
	
	if claim.qualifiers['P131'] then for _,eachUatQual in ipairs(claim.qualifiers['P131']) do
		if Wikidata.isValueSnak(eachUatQual) then
			table.insert(uats, eachUatQual.datavalue.value.id)
		end
	end end
	
	return uats, country
end

local function getClaimForTimestamp(entityId, propId, ts)
	local timestampedClaim = Wikidata.findClaimForTimestamp(entityId, propId, ts)
	if timestampedClaim and Wikidata.hasValueSnak(timestampedClaim) then
		local retVal = timestampedClaim
		local claimTs = nil
		if timestampedClaim.qualifiers and timestampedClaim.qualifiers['P582'] then
			for _,endTQual in ipairs(timestampedClaim.qualifiers['P582']) do if Wikidata.isValueSnak(endTQual) then
				claimTs = GregorianDate.convertToGregorianIfInInterval(DateUtils.extractDateFromWikidataSnak(endTQual))
				break
			end end
		end
		return retVal, claimTs
	end
	return nil, nil
end

local function getCountryIdForTimestamp(entityId, ts)
	local countryClaim, retTs = getClaimForTimestamp(entityId, 'P17', ts)

	if countryClaim and Wikidata.hasValueSnak(countryClaim) then
		return countryClaim.mainsnak.datavalue.value.id, retTs
	else
		return Wikidata.loadOneValueInChain({entityId, 'P17', 'raw'}), nil
	end
end	

-- returns 0, 1 or 2 - the number of admin units to be pulled
local function shouldPullUats(entityId, countryId)
	-- villages, rural settlements, should get 2 uats
	if Wikidata.isA(entityId, lacData.adminUnitExpandableLocationTypes) then
		return 2
	end
	-- locations in federal countries should get at least one UAT regardless of size
	if countryId and (Wikidata.isA(countryId, { 'Q22676603', 'Q43702' })
		or TableTools.contains(lacData.adminUnitExpandableCountries, countryId)) then
		return 1
	end
	-- only big cities should have just the country
	if not Wikidata.isA(entityId, {'Q1549591', 'Q1637706', 'Q200250'}) then
		return 1
	end
	return 0
end

local function recurseUats(entityId, ts)
	local crtUatId = entityId
	local crtCountryId = Wikidata.loadOneValueInChain({entityId, 'P17', 'raw'})
	local timestampedCountryId = getCountryIdForTimestamp(entityId, ts)
	local uatList = {}
	while crtUatId and crtUatId ~= crtCountryId and crtUatId ~= timestampedCountryId do
		local timestampedUatClaim = Wikidata.findClaimForTimestamp(crtUatId, 'P131', ts)
		crtUatId = timestampedUatClaim and Wikidata.hasValueSnak(timestampedUatClaim) and timestampedUatClaim.mainsnak.datavalue.value.id or Wikidata.loadOneValueInChain({crtUatId, 'P131', 'raw'})
		if (TableTools.contains(uatList, crtUatId)) then
			break
		end
		table.insert(uatList, crtUatId)
	end
	local uatListCountryId = nil
	if #uatList > 0 and (uatList[#uatList] == crtCountryId or uatList[#uatList] == timestampedCountryId or Wikidata.isA(uatList[#uatList], {'Q6256'})) then
		uatListCountryId  = table.remove(uatList, #uatList)
	end
	return uatList, uatListCountryId
end

local function shouldSkipLocation(entityId)
	return Wikidata.isA(entityId, lacData.escalatableLocationTypes)
end

local function trimUats(uatList)
	while #uatList > 0 and (Wikidata.isA(uatList[1], lacData.skippableUatTypes) or TableTools.contains(lacData.skippableUats, uatList[1])) do
		table.remove(uatList, 1)
	end
	while #uatList > 0 and (Wikidata.isA(uatList[#uatList], lacData.skippableUatTypes) or TableTools.contains(lacData.skippableUats, uatList[#uatList])) do
		table.remove(uatList, #uatList)
	end
	return uatList
end

local function resolvePartName(partId, ts, crtCountryId, uats)
	if lacData.locationNameOverrides[partId] then

		local timestampedLabel = getValueByTimestamp(lacData.locationNameOverrides[partId], ts)
		return illWd(partId, timestampedLabel)
	end

	local offLangCodes = { 'ro' }
	local offLangSource = nil
	local countryId = getCountryIdForTimestamp(partId, ts)
	
	if TableTools.contains(lacData.invariantLocations, partId) or
		(crtCountryId and TableTools.contains(lacData.invariantLocationCountries, crtCountryId))
		or TableTools.size(Set.valueIntersection(recurseUats(partId), lacData.invariantLocationUats)) > 0
		or Wikidata.isA(partId, lacData.invariantLocationTypes) then
		offLangCodes = { 'ro' }
	else
		-- look for (1) official language of the location
		local officialLangAtTsClaim = getClaimForTimestamp(partId, 'P37', ts)
		local officialLangClaims = officialLangAtTsClaim and { officialLangAtTsClaim } or Wikidata.findBestClaimsForProperty(partId, 'P37')
		--          (2) official language of one of the UATs
		if not officialLangClaims or #officialLangClaims == 0 then
			for uatIdx,eachUat in ipairs(uats or {}) do
				local uatOfficialLangAtTsClaim = getClaimForTimestamp(eachUat, 'P37', ts)
				local uatOfficialLangClaims = uatOfficialLangAtTsSnak and {uatOfficialLangAtTsClaim } or Wikidata.findBestClaimsForProperty(eachUat, 'P37')
				if not officialLangClaims or #officialLangClaims == 0 then
					officialLangClaims = uatOfficialLangClaims
					offLangSource = { qId = eachUat, srcType = 'uat', srcIdx = uatIdx }
				end
			end
		else
			offLangSource = { qId = partId, srcType = 'part' }
		end
		--          (3) official language of the country
		if not officialLangClaims or #officialLangClaims == 0 then
			if not countryId then return illWd(partId) end
			officialLangClaims = Wikidata.findBestClaimsForProperty(countryId, 'P37')
			offLangSource = { qId = countryId, srcType = 'country' }
		end

		for _,eachOffLangClaim in ipairs(officialLangClaims) do
			if Wikidata.hasValueSnak(eachOffLangClaim) and (not eachOffLangClaim.qualifiers or not eachOffLangClaim.qualifiers['P518']) then
				local eachOffLangId = eachOffLangClaim.mainsnak.datavalue.value.id
				local writingSystemQueue = Wikidata.getBestEntityIdsList(eachOffLangId, 'P282')
				local writingSystem = writingSystemQueue and table.remove(writingSystemQueue, 1)
				while writingSystem and writingSystem ~= '' and writingSystem ~= 8229 do
					TableTools.appendAll(writingSystemQueue, Wikidata.getBestEntityIdsList(writingSystem, 'P282'))
					writingSystem = table.remove(writingSystemQueue, 1)
				end
				local offLangCode = Wikidata.loadOneValueInChain({eachOffLangId, 'P218'})
				if offLangCode and offLangCode ~= '' then
					if writingSystem == 8229 or Transliteration.isTransliterationSupported(offLangCode) then
						table.insert(offLangCodes, offLangCode)
					end
				end
			end
		end
	end
	if #offLangCodes > 1 and offLangSource then
		--search config order
		local configOrder = lacData.languageOrder[offLangSource.qId]
		if offLangSource.srcType == 'part' or offLangSource.srcType == 'uat' then
			local startIdx = offLangSource.srcType == 'uat' and offLangSource.srcIdx or 1
			local crtIdx = startIdx
			while not configOrder and crtIdx <= #(uats or {}) do
				configOrder = configOrder or lacData.languageOrder[uats[crtIdx]]
				crtIdx = crtIdx + 1
			end
			configOrder = configOrder or lacData.languageOrder[countryId]
		end

		if configOrder then
			local sortedOffLangCodes = {}
			local unknownOffLangCodes = {}
			for _,eachLang in ipairs(configOrder) do
				if TableTools.contains(offLangCodes, eachLang) then
					table.insert(sortedOffLangCodes, eachLang)
				end
			end
			for _,eachLang in ipairs(offLangCodes) do
				if not TableTools.contains(sortedOffLangCodes, eachLang) then
					table.insert(sortedOffLangCodes, eachLang)
				end
			end
			offLangCodes = sortedOffLangCodes
		end
	end
	for _,offLangCode in ipairs(offLangCodes) do
		local wdPropForName = Wikidata.isA(partId, lacData.shortNameLocationTypes) and 'P1813' or 'P1448'
		
		local officialNameClaim = Wikidata.findClaimForTimestamp(partId, wdPropForName, ts, offLangCode)
		if officialNameClaim and Wikidata.isClaimTrue(officialNameClaim) and Wikidata.hasValueSnak(officialNameClaim) then
			local nameInOffLang = officialNameClaim.mainsnak.datavalue.value.text
			if wdPropForName == 'P1448' and (not officialNameClaim.qualifiers or not officialNameClaim.qualifiers['P582']) then -- if this is a former name, use it
			-- if this is the current name, then just get the label from that language
				nameInOffLang = mw.wikibase.getLabelByLang(partId, offLangCode)
			end
			return illWd(partId, Transliteration.isTransliterationSupported(offLangCode) and Transliteration.transliterate(nameInOffLang, offLangCode) or nameInOffLang)
		end
	end
	for _,offLangCode in ipairs(offLangCodes) do
		local labelInLang = Wikidata.findLabel(partId, offLangCode)
		if Transliteration.isTransliterationSupported(offLangCode) then
			labelInLang = Transliteration.transliterate(labelInLang, offLangCode)
		end
		return illWd(partId, labelInLang)
	end
	return nil
end

local function resolvePartNames(partIds, ts, crtCountryId, uats)
	if not partIds then return nil end
	local res = {}
	for _,partId in ipairs(partIds) do
		table.insert(res, resolvePartName(partId, ts, crtCountryId, uats))
	end
	return res
end

local function collapseCapitalledUat(locationEntityId, uatEntitiesIds)
	if not uatEntitiesIds or #uatEntitiesIds == 0 then return uatEntitiesIds end
	local out = {}
	local firstUatEntCapital = Wikidata.loadOneValueInChain({uatEntitiesIds[1], 'P36', 'raw'})
	if not firstUatEntCapital or firstUatEntCapital ~= locationEntityId then
		table.insert(out, uatEntitiesIds[1])
	end
	for idx = 2,#uatEntitiesIds do table.insert(out, uatEntitiesIds[idx]) end
	return out
		
end

local function displayFromParams(param, entity, timestamp, maxvalues, separator, enableRefs)

	if param == nil then return '' end
	
	local claims, workingEntityId = getClaimsForParam(entity, param)

	local ts = getTimestamp(timestamp, workingEntityId)

	local valueList = {}
	local maxvalues = maxvalues or 1
	if claims and 0 < #claims then
		for _,actualClaim in ipairs(claims) do
			local uatEntitiesIds = {}
			local countryId = nil
			local locationEntityId = nil
			if Wikidata.isClaimTrue(actualClaim) and Wikidata.hasValueSnak(actualClaim) then
				-- get admin unit(s) and/or country from qualifiers
				uatEntitiesIds, countryId = getUatsAndCountryFromQuals(actualClaim)
				locationEntityId = actualClaim.mainsnak.datavalue.value.id
				local countryByTs, countryTs = getCountryIdForTimestamp(locationEntityId, ts)

				countryId = countryId or countryByTs
				-- (1) see if admin unit needs to be pulled
				local uatsEnabled = shouldPullUats(locationEntityId, countryId)
				-- (2) pull all admin units based on timestamp until reaching nothing, self or country
				local allUats, uatCountryId = recurseUats(locationEntityId, ts)
				if uatsEnabled > 0 then
					if uatCountryId and uatCountryId ~= countryId and not countryTs then
						countryId = uatCountryId
					elseif countryTs and uatCountryId and uatCountryId ~= countryId then
						allUats = {}
					end
					-- (3) if the location itself is to be skipped, keep the first admin unit in the list as location
					while #allUats > 0 and shouldSkipLocation(locationEntityId) do
						locationEntityId = table.remove(allUats, 1)
					end
					-- (4) apply rules to eliminate from both ends
					local trimmedUats = trimUats(allUats)
					-- (5) keep only first and last (or the only one if only one is left)
					uatEntitiesIds = #trimmedUats == 0 and {} or #trimmedUats == 1 and trimmedUats or uatsEnabled == 1 and {trimmedUats[#trimmedUats]} or {trimmedUats[1], trimmedUats[#trimmedUats]}
					if #uatEntitiesIds > 1 then
						uatEntitiesIds = collapseCapitalledUat(locationEntityId, uatEntitiesIds)
					end
				else
					uatEntitiesIds = {}
				end
				local allPartIds = {}
				table.insert(allPartIds, locationEntityId)
				for __,eachUat in ipairs(uatEntitiesIds) do table.insert(allPartIds, eachUat) end
				local allPartLinks = resolvePartNames(allPartIds, ts, Wikidata.loadOneValueInChain({locationEntityId, 'P17', 'raw'}), allUats)
				if not countryId and uatEntitiesIds and #uatEntitiesIds > 0 then
					countryId = Wikidata.loadOneValueInChain({uatEntitiesIds[#uatEntitiesIds], 'P17', 'raw'})
				end
				if countryId and not TableTools.contains(allPartIds, countryId)
					and not Wikidata.isA(#uatEntitiesIds > 0 and uatEntitiesIds[#uatEntitiesIds] or locationEntityId, lacData.skipCountryTypes) then
					table.insert(allPartLinks, lacData.countryNameOverrides[countryId] and illWd(countryId, lacData.countryNameOverrides[countryId]) or resolvePartName(countryId, ts, countryId))
				end
				local crtVal = table.concat(allPartLinks, ', ')
				if enableRefs then crtVal = crtVal .. Wikidata.outputReferences(actualClaim) end
				table.insert(valueList, crtVal)
			end
			if #valueList >= maxvalues then
				break
			end
		end
	end
	return table.concat(valueList, separator or '; ')
end
p.displayFromParams = displayFromParams

local function displayFromArgs(args)
	local param = nil
	local entity = nil
	local timestamp = nil
	local maxvalues = 1
	local separator = '; '
	if args[1] or args['param'] then
		param = args[1] or args['param']
	end
	if args[2] or args['entityId'] then
		entity = args[2] or args['entityId']
	end
	if args[3] or args['timestamp'] then
		timestamp = args[3] or args['timestamp']
	end
	if args[4] or args['maxvalues'] then
		maxvalues = tonumber(args[4] or args['maxvalues'])
	end
	if args[5] or args['separator'] then
		separator = args[5] or args['separator']
	end
	return displayFromParams(param, entity, timestamp, maxvalues, separator)
end
p.displayFromArgs = displayFromArgs

p.displayFromFrame = function(frame)
	local args = getArgs(frame, { frameOnly = true })
	return displayFromArgs(args)
end

p.displayFromParentFrame = function(frame)
	local args = getArgs(frame, { parentOnly = true})
	return displayFromArgs(args)
end

return p