Vizualizare sursă pentru „Modul:LocationAndCountry”

← Modul:LocationAndCountry
Nu aveți permisiunea de a modifica această pagină, din următoarele motive:
Această pagină este protejată.
Ea poate fi modificată doar de editori de formate.
Dacă doriți să propuneți o modificare vă rugăm să lăsați un mesaj în pagina de discuții.
Pentru a cere deprotejarea paginii urmați instrucțiunile de la pagina Cereri protejare/deprotejare.
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis.
The block was made by ‪EPIC‬. The reason given is Open proxy/Webhost: See the help page if you are affected.
- Start of block: 2 iulie 2024 10:48
- Expiry of block: 2 iulie 2025 10:48
Your current IP address is 206.189.44.186. The blocked range is 206.189.32.0/20.
Vă rugăm să includeți toate detaliile de mai sus în orice mesaje. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy.
Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.
Puteți vedea și copia codul sursă al paginii:
-- 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
Formate folosite în această pagină:
Format:F (vedeți sursa) (protejat ca format)
Modul:LocationAndCountry/doc (modificare)
Înapoi la Modul:LocationAndCountry.
Adus de la https://ro.wikipedia.org/wiki/Modul:LocationAndCountry