יחידה:LocationAndCountry - ווערסיע היסטאריע

תנא קמא אין 11:20, 10 מערץ 2023

2023-03-10T11:20:06Z

→ עלטערע ווערסיע		רעוויזיע פון 11:20, 10 מערץ 2023
שורה 15:		שורה 15:
	-- the fifth argument specifies the separator to use when displaying multiple values		-- the fifth argument specifies the separator to use when displaying multiple values
	local getArgs = require('Module:Arguments').getArgs		local getArgs = require('Module:Arguments').getArgs
	local HeDateUtils = require('Module:~~תאריך~~')		local HeDateUtils = require('Module:דאטום')
	local TableTools = require('Module:TableTools')		local TableTools = require('Module:TableTools')
	local PropertyLink = require('Module:PropertyLink')		local PropertyLink = require('Module:PropertyLink')

תנא קמא: קאטעגאריע

2023-03-06T06:27:23Z

קאטעגאריע

→ עלטערע ווערסיע		רעוויזיע פון 06:27, 6 מערץ 2023
שורה 150:		שורה 150:

	local function missingLabelCategory(propertyName)		local function missingLabelCategory(propertyName)
	return '[[~~קטגוריה~~:ויקינתונים:ערכים_חסרי_תווית_בעברית: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[~~קטגוריה~~:ויקינתונים:ערכים_חסרי_תווית_בעברית]]'		return '[[קאטעגאריע:ויקינתונים:ערכים_חסרי_תווית_בעברית: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[קאטעגאריע:ויקינתונים:ערכים_חסרי_תווית_בעברית]]'
	end		end

תנא קמא: אפדעיט

2023-03-05T14:22:10Z

אפדעיט

→ עלטערע ווערסיע		רעוויזיע פון 14:22, 5 מערץ 2023
שורה 1:		שורה 1:
	--[[Adapted from ro:Modul:LocationAndCountry with changes:		--[[Adapted from ro:Modul:LocationAndCountry with changes:
	* Using PropertyLink for linking format		* Using PropertyLink for linking format
	* No use of external modules that exist in rowiki but have different version in ~~yiwiki~~ such as wikidata and date modules		* No use of external modules that exist in rowiki but have different version in hewiki such as wikidata and date modules
	* findLinkToItem/findDateValues/findClaimForTimestamp is local instead of wikidata module		* findLinkToItem/findDateValues/findClaimForTimestamp is local instead of wikidata module
	* disabled capabilities:		* disabled capabilities:
שורה 15:		שורה 15:
	-- the fifth argument specifies the separator to use when displaying multiple values		-- the fifth argument specifies the separator to use when displaying multiple values
	local getArgs = require('Module:Arguments').getArgs		local getArgs = require('Module:Arguments').getArgs
	local HeDateUtils = require('Module:~~דאטע~~')		local HeDateUtils = require('Module:תאריך')
	local TableTools = require('Module:TableTools')		local TableTools = require('Module:TableTools')
	local PropertyLink = require('Module:PropertyLink')		local PropertyLink = require('Module:PropertyLink')
שורה 150:		שורה 150:

	local function missingLabelCategory(propertyName)		local function missingLabelCategory(propertyName)
	return '[[~~קאטעגאריע~~:~~וויקידאטן עטיקעט פעלט אין יידיש~~: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[~~קאטעגאריע~~:~~וויקידאטן עטיקעט פעלט אין יידיש~~]]'		return '[[קטגוריה:ויקינתונים:ערכים_חסרי_תווית_בעברית: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[קטגוריה:ויקינתונים:ערכים_חסרי_תווית_בעברית]]'
	end		end

שורה 157:		שורה 157:
	local claims = nil		local claims = nil
	local workingEntityId = nil		local workingEntityId = nil
			local countryProperty = 'P17'
			local administrativeUnitProperty = 'P131'
	if type(entity) == 'table' then		if type(entity) == 'table' then
	workingEntityId = entity.id		workingEntityId = entity.id
שורה 181:		שורה 183:

	--attempt to also load administrative unit, but only if present as a qualifier		--attempt to also load administrative unit, but only if present as a qualifier
	local unitQualifier = actualClaim.qualifiers and actualClaim.qualifiers[~~'P131'~~] and actualClaim.qualifiers[~~'P131'~~][1]		local unitQualifier = actualClaim.qualifiers and actualClaim.qualifiers[administrativeUnitProperty] and actualClaim.qualifiers[administrativeUnitProperty][1]
	if unitQualifier and unitQualifier.snaktype == 'value' then		if unitQualifier and unitQualifier.snaktype == 'value' then
	table.insert(locationEntitiesIds, unitQualifier.datavalue.value.id)		table.insert(locationEntitiesIds, unitQualifier.datavalue.value.id)
שורה 188:		שורה 190:

	-- attempt to identify country in the qualifier first, but if it's not, go to the entity		-- attempt to identify country in the qualifier first, but if it's not, go to the entity
	local countryQualifier = actualClaim.qualifiers and actualClaim.qualifiers[~~'P17'~~] and actualClaim.qualifiers[~~'P17'~~][1]		local countryQualifier = actualClaim.qualifiers and actualClaim.qualifiers[countryProperty] and actualClaim.qualifiers[countryProperty][1]
	local countryId = nil		local countryId = nil
	local ts = nil		local ts = nil
שורה 218:		שורה 220:
	end		end

	countryClaim = findClaimForTimestamp(locationEntityId, ~~'P17'~~, ts)		countryClaim = findClaimForTimestamp(locationEntityId, countryProperty, ts)
	if countryClaim and countryClaim.mainsnak and countryClaim.mainsnak.snaktype == 'value' then		if countryClaim and countryClaim.mainsnak and countryClaim.mainsnak.snaktype == 'value' then
	countryId = countryClaim.mainsnak.datavalue.value.id		countryId = countryClaim.mainsnak.datavalue.value.id
שורה 245:		שורה 247:
	]]		]]
	end		end

			-- don't show in case of missing label
	if not missingEntityLabel then		if not missingEntityLabel then
	table.insert(locationNamesList, locationNames[eachLocationId])		table.insert(locationNamesList, locationNames[eachLocationId])

תנא קמא: 1 רעוויזיע אימפארטירט פון :wikipedia:he:יחידה:LocationAndCountry

2023-02-06T04:14:50Z

1 רעוויזיע אימפארטירט פון wikipedia:he:יחידה:LocationAndCountry

→ עלטערע ווערסיע	רעוויזיע פון 04:14, 6 פעברואר 2023
(קיין אונטערשייד)

שרגא: 1 רעוויזיע אימפארטירט: אימפארטירט פון די יידישע וויקיפעדיע, זע ביישטייערער ליסטע

2022-11-24T13:54:38Z

1 רעוויזיע אימפארטירט: אימפארטירט פון די יידישע וויקיפעדיע, זע ביישטייערער ליסטע

→ עלטערע ווערסיע	רעוויזיע פון 13:54, 24 נאוועמבער 2022
(קיין אונטערשייד)

yi>Hasley: rv

2022-04-13T12:21:50Z

→ עלטערע ווערסיע		רעוויזיע פון 12:21, 13 אפריל 2022
שורה 1:		שורה 1:
	--[[Adapted from ro:Modul:LocationAndCountry with changes:		--[[Adapted from ro:Modul:LocationAndCountry with changes:
	* Using PropertyLink for linking format		* Using PropertyLink for linking format
	* No use of external modules that exist in rowiki but have different version in ~~hewiki~~ such as wikidata and date modules		* No use of external modules that exist in rowiki but have different version in yiwiki such as wikidata and date modules
	* findLinkToItem/findDateValues/findClaimForTimestamp is local instead of wikidata module		* findLinkToItem/findDateValues/findClaimForTimestamp is local instead of wikidata module
	* disabled capabilities:		* disabled capabilities:
שורה 15:		שורה 15:
	-- the fifth argument specifies the separator to use when displaying multiple values		-- the fifth argument specifies the separator to use when displaying multiple values
	local getArgs = require('Module:Arguments').getArgs		local getArgs = require('Module:Arguments').getArgs
	local HeDateUtils = require('Module:~~תאריך~~')		local HeDateUtils = require('Module:דאטע')
	local TableTools = require('Module:TableTools')		local TableTools = require('Module:TableTools')
	local PropertyLink = require('Module:PropertyLink')		local PropertyLink = require('Module:PropertyLink')
שורה 150:		שורה 150:

	local function missingLabelCategory(propertyName)		local function missingLabelCategory(propertyName)
	return '[[~~קטגוריה~~:~~ויקינתונים:ערכים_חסרי_תווית_בעברית~~: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[~~קטגוריה:ויקינתונים~~:~~ערכים_חסרי_תווית_בעברית~~]]'		return '[[קאטעגאריע:וויקידאטן עטיקעט פעלט אין יידיש: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[קאטעגאריע:וויקידאטן עטיקעט פעלט אין יידיש]]'
	end		end

שורה 157:		שורה 157:
	local claims = nil		local claims = nil
	local workingEntityId = nil		local workingEntityId = nil
	~~local countryProperty = 'P17'~~
	~~local administrativeUnitProperty = 'P131'~~
	if type(entity) == 'table' then		if type(entity) == 'table' then
	workingEntityId = entity.id		workingEntityId = entity.id
שורה 183:		שורה 181:

	--attempt to also load administrative unit, but only if present as a qualifier		--attempt to also load administrative unit, but only if present as a qualifier
	local unitQualifier = actualClaim.qualifiers and actualClaim.qualifiers[~~administrativeUnitProperty~~] and actualClaim.qualifiers[~~administrativeUnitProperty~~][1]		local unitQualifier = actualClaim.qualifiers and actualClaim.qualifiers['P131'] and actualClaim.qualifiers['P131'][1]
	if unitQualifier and unitQualifier.snaktype == 'value' then		if unitQualifier and unitQualifier.snaktype == 'value' then
	table.insert(locationEntitiesIds, unitQualifier.datavalue.value.id)		table.insert(locationEntitiesIds, unitQualifier.datavalue.value.id)
שורה 190:		שורה 188:

	-- attempt to identify country in the qualifier first, but if it's not, go to the entity		-- attempt to identify country in the qualifier first, but if it's not, go to the entity
	local countryQualifier = actualClaim.qualifiers and actualClaim.qualifiers[~~countryProperty~~] and actualClaim.qualifiers[~~countryProperty~~][1]		local countryQualifier = actualClaim.qualifiers and actualClaim.qualifiers['P17'] and actualClaim.qualifiers['P17'][1]
	local countryId = nil		local countryId = nil
	local ts = nil		local ts = nil
שורה 220:		שורה 218:
	end		end

	countryClaim = findClaimForTimestamp(locationEntityId, ~~countryProperty~~, ts)		countryClaim = findClaimForTimestamp(locationEntityId, 'P17', ts)
	if countryClaim and countryClaim.mainsnak and countryClaim.mainsnak.snaktype == 'value' then		if countryClaim and countryClaim.mainsnak and countryClaim.mainsnak.snaktype == 'value' then
	countryId = countryClaim.mainsnak.datavalue.value.id		countryId = countryClaim.mainsnak.datavalue.value.id
שורה 247:		שורה 245:
	]]		]]
	end		end

	~~-- don't show in case of missing label~~
	if not missingEntityLabel then		if not missingEntityLabel then
	table.insert(locationNamesList, locationNames[eachLocationId])		table.insert(locationNamesList, locationNames[eachLocationId])

wikipedia:he>ערן: הוספת התנאי חזרה

2021-09-04T10:15:43Z

הוספת התנאי חזרה

נייער בלאַט

--[[Adapted from ro:Modul:LocationAndCountry with changes:
* Using PropertyLink for linking format
* No use of external modules that exist in rowiki but have different version in hewiki such as wikidata and date modules
* findLinkToItem/findDateValues/findClaimForTimestamp is local instead of wikidata module
* disabled capabilities:
* outputReferences
* offical/short name
]]

-- 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('Module:Arguments').getArgs
local HeDateUtils = require('Module:תאריך')
local TableTools = require('Module:TableTools')
local PropertyLink = require('Module:PropertyLink')

local p = {}

function emptyToNil(args)
local str = args[1]
if str == '' then return nil end
return str
end

local function isValueSnak(snak)
return snak and snak.snaktype == 'value'
end

local function hasValueSnak(claim)
return claim and claim.type == 'statement' and isValueSnak(claim.mainsnak)
end

local function findDateValues(propertyId, entityId)
entityId = entityId or mw.wikibase.getEntityIdForCurrentPage()

if entityId then
local bestclaims = mw.wikibase.getBestStatements(entityId, propertyId)
local bestdates = {}

if bestclaims then for k, v in pairs(bestclaims) do
if hasValueSnak(v) and v.mainsnak.datatype == 'time' then
local d = HeDateUtils.newFromWikidataValue(v.mainsnak.datavalue.value)
d.claim = v
table.insert(bestdates, d)
elseif hasValueSnak(v) then
local d = {}
d.claim = v
table.insert(bestdates, d)
end
end end
return bestdates
end
end

local timestampComparator = function(p1, p2)
if p1 and p2 then
local q1 = p1.qualifiers
local q2 = p2.qualifiers
local d1 = nil
local d2 = nil
if q1 and q2 then
if q1['P580'] and q1['P580'][1] and q1['P580'][1].datavalue then
d1 = HeDateUtils.newFromWikidataValue(q1['P580'][1].datavalue.value)
end
if q2['P580'] and q2['P580'][1] and q2['P580'][1].datavalue then
d2 = HeDateUtils.newFromWikidataValue(q2['P580'][1].datavalue.value)
end

if d1 and d2 then return not HeDateUtils.le(d2, d1, true)
elseif d1 then return true
elseif d2 then return false end
elseif q1 then return true
elseif q2 then return false
end
else
if p1 then return true end
if p2 then return false end
end
return false
end

local function findSortedClaimsForProperty(entity, propertyId)
if entity == nil then entity = mw.wikibase.getEntityIdForCurrentPage() end
local rawClaims = mw.wikibase.getAllStatements(entity, propertyId)
if rawClaims == nil then return {} end

table.sort(rawClaims, timestampComparator)
return rawClaims
end

local function findClaimForTimestamp(entityId, propertyId, timestamp)
local propClaims = findSortedClaimsForProperty(entityId, propertyId)
local bestClaims = {}
local bestNoTimeClaim

if propClaims then for _,eachPropClaim in ipairs(propClaims) do
if hasValueSnak(eachPropClaim)
and mw.wikibase.entity.claimRanks['RANK_' .. mw.ustring.upper(eachPropClaim.rank)] >= mw.wikibase.entity.claimRanks.RANK_NORMAL then

if eachPropClaim.mainsnak.datavalue.type ~= 'monolingualtext' or eachPropClaim.mainsnak.datavalue.value.language == 'he' then
local before = nil
local after = nil
if eachPropClaim.qualifiers then
if eachPropClaim.qualifiers['P580'] and eachPropClaim.qualifiers['P580'][1] and isValueSnak(eachPropClaim.qualifiers['P580'][1]) then
before = HeDateUtils.julianToGregorian(HeDateUtils.newFromWikidataValue(eachPropClaim.qualifiers['P580'][1].datavalue.value))
--after = GregorianDate.convertToGregorianIfInInterval(DateUtils.extractDateFromWikidataSnak(eachPropClaim.qualifiers['P580'][1]))
end
if eachPropClaim.qualifiers['P582'] and eachPropClaim.qualifiers['P582'][1] and isValueSnak(eachPropClaim.qualifiers['P582'][1]) then
after = HeDateUtils.julianToGregorian(HeDateUtils.newFromWikidataValue(eachPropClaim.qualifiers['P582'][1].datavalue.value))
--before = GregorianDate.convertToGregorianIfInInterval(DateUtils.extractDateFromWikidataSnak(eachPropClaim.qualifiers['P582'][1]))
end
end

if timestamp then
if after == nil and before and not HeDateUtils.le(timestamp, before) then
table.insert(bestClaims, eachPropClaim)
elseif after and before and not HeDateUtils.le(timestamp, before) and HeDateUtils.le(timestamp, after) then
table.insert(bestClaims, eachPropClaim)
elseif after and before == nil and HeDateUtils.le(timestamp, after) then
table.insert(bestClaims, eachPropClaim)
end
end
if not bestNoTimeClaim or mw.wikibase.entity.claimRanks['RANK_' .. mw.ustring.upper(bestNoTimeClaim.rank)] < mw.wikibase.entity.claimRanks['RANK_' .. mw.ustring.upper(eachPropClaim.rank)]
or (mw.wikibase.entity.claimRanks['RANK_' .. mw.ustring.upper(bestNoTimeClaim.rank)] < mw.wikibase.entity.claimRanks['RANK_' .. mw.ustring.upper(eachPropClaim.rank)] and not after) then

bestNoTimeClaim = eachPropClaim
end
end
end
end end

if #bestClaims==0 and bestNoTimeClaim then
return bestNoTimeClaim
end
if #bestClaims==1 then
return bestClaims[1]
elseif (#bestClaims>1) and timestamp then
-- disambig: return null and log it
mw.log('לא ניתן לשייך מיקום ליישות '..entityId .. ' כיוון שקיימות מספר טענות מתאימות שנכונות ל'..timestamp:toString()..'. ניתן לציין מבחין להגדרה חד ערכית.')
return nil
else
return nil
end
end

local function missingLabelCategory(propertyName)
return '[[קטגוריה:ויקינתונים:ערכים_חסרי_תווית_בעברית: ' .. (mw.wikibase.label( propertyName) or propertyName) .. ']][[קטגוריה:ויקינתונים:ערכים_חסרי_תווית_בעברית]]'
end

p.displayFromParams = function(param, entity, timestamp, maxvalues, separator)
if param == nil then return '' end
local claims = nil
local workingEntityId = nil
local countryProperty = 'P17'
local administrativeUnitProperty = 'P131'
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

local valueList = {}
local valueCount = 0
local missingLabel = false
if claims and 0 < #claims then
for claimIdx, actualClaim in pairs(claims) do
valueCount = valueCount + 1
local locationEntitiesIds = {}
local locationNames = {}
if actualClaim.mainsnak and actualClaim.mainsnak.snaktype == 'value' and actualClaim.mainsnak.datavalue.type == 'wikibase-entityid' then
local locationEntityId =actualClaim.mainsnak.datavalue.value.id
table.insert(locationEntitiesIds, locationEntityId)

--attempt to also load administrative unit, but only if present as a qualifier
local unitQualifier = actualClaim.qualifiers and actualClaim.qualifiers[administrativeUnitProperty] and actualClaim.qualifiers[administrativeUnitProperty][1]
if unitQualifier and unitQualifier.snaktype == 'value' then
table.insert(locationEntitiesIds, unitQualifier.datavalue.value.id)
locationNames[unitQualifier.datavalue.value.id] = PropertyLink.formatEntity(unitQualifier.datavalue.value.id)
end

-- attempt to identify country in the qualifier first, but if it's not, go to the entity
local countryQualifier = actualClaim.qualifiers and actualClaim.qualifiers[countryProperty] and actualClaim.qualifiers[countryProperty][1]
local countryId = nil
local ts = nil
if countryQualifier and countryQualifier.snaktype == 'value' then
table.insert(locationEntitiesIds, countryQualifier.datavalue.value.id)
locationNames[countryQualifier.datavalue.value.id] = PropertyLink.formatEntity(countryQualifier.datavalue.value.id)
else
local countryClaim = nil
if timestamp then
if type(timestamp) == 'string' and mw.ustring.gmatch(timestamp, 'P%d+') then
local wdDates = findDateValues(timestamp, workingEntityId)
if wdDates and 0 < #wdDates then
local wdDateIdx = 1
while wdDateIdx <= #wdDates and (wdDates[wdDateIdx].claim.type ~= 'statement' or wdDates[wdDateIdx].claim.mainsnak.snaktype ~= 'value') do
wdDateIdx = wdDateIdx + 1
end
if wdDateIdx <= #wdDates and (wdDates[wdDateIdx].claim.type == 'statement' and wdDates[wdDateIdx].claim.mainsnak.snaktype == 'value') then
--wdDates[wdDateIdx] = GregorianDate.convertToGregorianIfInInterval(wdDates[wdDateIdx])
wdDates[wdDateIdx] = HeDateUtils.julianToGregorian(wdDates[wdDateIdx])
ts = wdDates[wdDateIdx]
end
end
end
if ts == nil and type(timestamp) == 'string' then
ts = HeDateUtils.parseYear(timestamp)
elseif ts == nil and type(timestamp) == 'table' and timestamp.year then
ts = timestamp
end
end

countryClaim = findClaimForTimestamp(locationEntityId, countryProperty, ts)
if countryClaim and countryClaim.mainsnak and countryClaim.mainsnak.snaktype == 'value' then
countryId = countryClaim.mainsnak.datavalue.value.id
table.insert(locationEntitiesIds, countryId)
end
end
locationEntitiesIds = TableTools.removeDuplicates(locationEntitiesIds)
local locationNamesList = {}

for _,eachLocationId in ipairs(locationEntitiesIds) do
local missingEntityLabel = false
if not locationNames[eachLocationId] then
locationNames[eachLocationId], missingEntityLabel = PropertyLink.formatEntity(eachLocationId)
missingLabel = missingLabel or missingEntityLabel

--[[ Disabled feature from ro wiki: show the offical name/short name in that timestamp
local correspindingShortNameClaim = findClaimForTimestamp(eachLocationId, 'P1813', ts)
if correspindingShortNameClaim then
locationNames[eachLocationId]= correspindingShortNameClaim.mainsnak.datavalue.value.text
else
local correspondingOfficialNameClaim = findClaimForTimestamp(eachLocationId, 'P1448', ts)
if correspondingOfficialNameClaim then
locationNames[eachLocationId] = correspondingOfficialNameClaim.mainsnak.datavalue.value.text
end
end
]]
end

-- don't show in case of missing label
if not missingEntityLabel then
table.insert(locationNamesList, locationNames[eachLocationId])
end
end
if 0 < #locationNamesList then
table.insert(
valueList,
--appendToString({
emptyToNil({table.concat(locationNamesList, ', ')})
-- wikidata.outputReferences(actualClaim)
--})
)
end
end
end
end
if #valueList == 0 then return '' end
if separator == nil then separator = '; ' end
if maxvalues > #valueList then maxvalues = #valueList end
if missingLabel then
return table.concat(valueList, separator, 1, maxvalues) .. missingLabelCategory(param)
else
return table.concat(valueList, separator, 1, maxvalues)
end
end

p.displayFromArgs = function(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 p.displayFromParams(param, entity, timestamp, maxvalues, separator)
end

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

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

return p