پودمان:AlborzSports

توضیحات این پودمان می‌تواند در پودمان:AlborzSports/توضیحات قرار گیرد.

--------------------------------------------------------------------------------
-- Module:AlborzSports
-- Wiki Alborz Sports Information System
-- Core Engine
-- Version 2.2
--------------------------------------------------------------------------------
local p = {}
--------------------------------------------------------------------------------
-- LOAD DATA
--------------------------------------------------------------------------------
local data = mw.loadData("Module:AlborzSports/Data")
--------------------------------------------------------------------------------
-- CONFIG
--------------------------------------------------------------------------------
local DEFAULT_IMAGE_WIDTH =
data.meta.imageWidth or "280px"
--------------------------------------------------------------------------------
-- UTILITY FUNCTIONS
--------------------------------------------------------------------------------
local function clean(value)
	if value == nil then
		return nil
	end
	if type(value) == "string" then
		value = mw.text.trim(value)
		if value == "" then
			return nil
		end
	end
	return value
end
--------------------------------------------------------------------------------
-- GET ARGUMENTS
--------------------------------------------------------------------------------
local function getArgs(frame)
	local args = {}
	local source = frame
	local parent = frame:getParent()
	if parent and next(parent.args) then
		source = parent
	end
	for key, value in pairs(source.args) do
		local cleanKey =
		mw.text.trim(tostring(key))
		local cleanValue =
		clean(value)
		if cleanKey ~= "" and cleanValue then
			args[cleanKey] = cleanValue
		end
	end
	return args
end
--------------------------------------------------------------------------------
-- NORMALIZE INPUT
--------------------------------------------------------------------------------
local function normalize(args)
	local result = {}
	for key, value in pairs(args) do
		local field =
		data.lookup[key] or key
		result[field] = value
	end
	return result
end
--------------------------------------------------------------------------------
-- ENTITY ALIASES
--------------------------------------------------------------------------------
local entityAliases = {
	-- People
	player = "player",
	athlete = "player",
	["بازیکن"] = "player",
	["ورزشکار"] = "player",
	coach = "coach",
	["مربی"] = "coach",
	referee = "referee",
	["داور"] = "referee",
	manager = "manager",
	["مدیر ورزشی"] = "manager",
	-- Clubs
	club = "club",
	sports_club = "club",
	sport_club = "club",
	["باشگاه"] = "club",
	["باشگاه ورزشی"] = "club",
	-- Academy
	academy = "academy",
	["آکادمی"] = "academy",
	["آکادمی ورزشی"] = "academy",
	-- Facilities
	stadium = "stadium",
	["ورزشگاه"] = "stadium",
	gym = "gym",
	gymnasium = "gym",
	["سالن"] = "gym",
	["سالن ورزشی"] = "gym",
	pool = "pool",
	swimming_pool = "pool",
	["استخر"] = "pool",
	zurkhaneh = "zurkhaneh",
	["زورخانه"] = "zurkhaneh",
	sports_school = "sports_school",
	["مدرسه ورزشی"] = "sports_school",
	sports_complex = "sports_complex",
	["مجموعه ورزشی"] = "sports_complex",
	facility = "facility",
	["مجموعه"] = "facility",
	-- Organization / Board
	board = "board",
	sports_board = "board",
	["هیئت"] = "board",
	["هیئت ورزشی"] = "board",
	-- Competition
	competition = "competition",
	["مسابقه"] = "competition",
	["مسابقات"] = "competition"
}
--------------------------------------------------------------------------------
-- ENTITY DETECTION
--------------------------------------------------------------------------------
local function getEntity(args)
	local entity = clean(args.entity_type)

	----------------------------------------------------------------
	-- DEFAULT ENTITY
	----------------------------------------------------------------
	if not entity then
		entity = data.defaults.entity_type
	end

	----------------------------------------------------------------
	-- NORMALIZE ENTITY
	----------------------------------------------------------------
	entity = entityAliases[entity] or entity

	----------------------------------------------------------------
	-- VALID ENTITY
	----------------------------------------------------------------
	if data.entities[entity] then
		return entity
	end

	----------------------------------------------------------------
	-- INFERENCE FROM SUBTYPE (نوع)
	----------------------------------------------------------------
	local subtype = clean(args.subtype)
	if subtype then
		-- باشگاه
		if mw.ustring.find(subtype, "باشگاه") or mw.ustring.find(mw.ustring.lower(subtype), "club") then
			return "club"
		end
		-- آکادمی
		if mw.ustring.find(subtype, "آکادمی") or mw.ustring.find(mw.ustring.lower(subtype), "academy") then
			return "academy"
		end
		-- ورزشگاه
		if mw.ustring.find(subtype, "ورزشگاه") or mw.ustring.find(mw.ustring.lower(subtype), "stadium") then
			return "stadium"
		end
		-- سالن ورزشی
		if mw.ustring.find(subtype, "سالن") or mw.ustring.find(mw.ustring.lower(subtype), "gym") then
			return "gym"
		end
		-- استخر
		if mw.ustring.find(subtype, "استخر") or mw.ustring.find(mw.ustring.lower(subtype), "pool") then
			return "pool"
		end
		-- زورخانه
		if mw.ustring.find(subtype, "زورخانه") then
			return "zurkhaneh"
		end
		-- مدرسه ورزشی
		if mw.ustring.find(subtype, "مدرسه") then
			return "sports_school"
		end
		-- مجموعه ورزشی
		if mw.ustring.find(subtype, "مجموعه") then
			return "sports_complex"
		end
		-- هیئت
		if mw.ustring.find(subtype, "هیئت") then
			return "board"
		end
	end

	----------------------------------------------------------------
	-- INFERENCE FROM FIELDS (اگر subtype هم نبود)
	----------------------------------------------------------------
	if args.established
		or args.manager
		or args.owner
		or args.president
		or args.ceo
		or args.stadium
		or args.capacity
		or args.facilities
		or args.services
		or (args.address and args.city)
	then
		-- اگر فیلدهای سازمانی وجود داشت → باشگاه/مجموعه
		if args.stadium or args.capacity then
			return "stadium"
		end
		return "club"
	end

	----------------------------------------------------------------
	-- SAFE FALLBACK
	----------------------------------------------------------------
	local defaultEntity = data.defaults.entity_type or "player"
	defaultEntity = entityAliases[defaultEntity] or defaultEntity

	if data.entities[defaultEntity] then
		return defaultEntity
	end

	return "player"
end
--------------------------------------------------------------------------------
-- TITLE
--------------------------------------------------------------------------------
local function getTitle(entity, args)
	if args.name then
		return args.name
	end
	local entityData =
	data.entities[entity]
	if entityData and entityData.title then
		return entityData.title
	end
	return data.meta.title
end
--------------------------------------------------------------------------------
-- IMAGE HANDLING
--------------------------------------------------------------------------------
local function buildImage(args)
	if not args.image then
		return nil
	end
	local width =
	args.image_width
	or DEFAULT_IMAGE_WIDTH
	local caption =
	args.caption
	or ""
	return {
		type = "image",
		image = args.image,
		size = width,
		caption = caption
	}
end
--------------------------------------------------------------------------------
-- FIELD BUILDER
--------------------------------------------------------------------------------
local function buildFields(layout, args)
	local fields = {}
	for _, item in ipairs(layout) do
		local label =
		item[1]
		local key =
		item[2]
		local value =
		clean(args[key])
		----------------------------------------------------------------
		-- ONLY ADD EXISTING VALUES
		----------------------------------------------------------------
		if value then
			table.insert(
			fields,
			{
				label = label,
				value = value
			}
			)
		end
	end
	return fields
end
--------------------------------------------------------------------------------
-- GROUP BUILDER
--------------------------------------------------------------------------------
local function buildGroups(entity, args)
	local groups = {}
	local entityData =
	data.entities[entity]
	if not entityData then
		return groups
	end
	----------------------------------------------------------------
	-- USE ONLY ENTITY-SPECIFIC LAYOUTS
	--
	-- IMPORTANT:
	-- "base" is NOT automatically added.
	-- It is displayed only when explicitly included
	-- in the entity's layouts.
	----------------------------------------------------------------
	for _, layoutName in ipairs(entityData.layouts or {}) do
		local layout =
		data.layouts[layoutName]
		if layout then
			local fields =
			buildFields(
			layout,
			args
			)
			----------------------------------------------------------------
			-- DO NOT DISPLAY EMPTY GROUPS
			----------------------------------------------------------------
			if #fields > 0 then
				local title =
				data.layoutTitles[layoutName]
				or layoutName
				table.insert(
				groups,
				{
					name = title,
					fields = fields
				}
				)
			end
		end
	end
	return groups
end
--------------------------------------------------------------------------------
-- MEDAL BUILDER
--------------------------------------------------------------------------------
local function buildMedals(args)
	local medals =
	clean(args.medaltemplates)
	if not medals then
		medals =
		clean(args.medals)
	end
	if not medals then
		return nil
	end
	local frame =
	mw.getCurrentFrame()
	local content =
	frame:expandTemplate{
		title = "Infobox medal templates",
		args = {
			medals = medals,
			title =
			args.medaltemplates_title
			or "",
			expand = "yes"
		}
	}
	content =
	clean(content)
	if not content then
		return nil
	end
	return content
end
--------------------------------------------------------------------------------
-- INFOBOX BUILDER
--------------------------------------------------------------------------------
local function buildInfobox(entity, args)
	local box = {}
	----------------------------------------------------------------
	-- TITLE
	----------------------------------------------------------------
	box.title =
	getTitle(
	entity,
	args
	)
	----------------------------------------------------------------
	-- IMAGE
	----------------------------------------------------------------
	local image =
	buildImage(args)
	if image then
		box.image = image
	end
	----------------------------------------------------------------
	-- GROUPS
	----------------------------------------------------------------
	box.groups =
	buildGroups(
	entity,
	args
	)
	----------------------------------------------------------------
	-- MEDALS
	----------------------------------------------------------------
	box.medals =
	buildMedals(args)
	return box
end
--------------------------------------------------------------------------------
-- RENDER VALUE
--------------------------------------------------------------------------------
local function renderValue(value)
	if type(value) == "table" then
		return table.concat(
		value,
		"، "
		)
	end
	return tostring(value)
end
--------------------------------------------------------------------------------
-- ESCAPE HTML
--------------------------------------------------------------------------------
local function escape(value)
	if value == nil then
		return ""
	end
	return mw.text.nowiki(
	tostring(value)
	)
end
--------------------------------------------------------------------------------
-- RENDER INFOBOX
--------------------------------------------------------------------------------
local function renderInfobox(box)
	local result = {}
	----------------------------------------------------------------
	-- OPEN TABLE
	----------------------------------------------------------------
	table.insert(
	result,
	'<table class="sport-infobox">'
	)
	----------------------------------------------------------------
	-- TITLE
	----------------------------------------------------------------
	if box.title then
		table.insert(
		result,
		'<tr class="sport-infobox-title">' ..
		'<th colspan="2">' ..
		box.title ..
		'</th></tr>'
		)
	end
	----------------------------------------------------------------
	-- IMAGE
	----------------------------------------------------------------
	if box.image then
		local image =
		box.image
		local file =
		image.image
		local size =
		image.size
		or DEFAULT_IMAGE_WIDTH
		local caption =
		image.caption
		or ""
		table.insert(
		result,
		'<tr>' ..
		'<td colspan="2" class="sport-infobox-image">' ..
		'[[File:' ..
		file ..
		'|' ..
		size ..
		']]'
		)
		if caption ~= "" then
			table.insert(
			result,
			'<div class="sport-infobox-caption">' ..
			caption ..
			'</div>'
			)
		end
		table.insert(
		result,
		'</td></tr>'
		)
	end
	----------------------------------------------------------------
	-- GROUPS
	----------------------------------------------------------------
	for _, group in ipairs(box.groups) do
		----------------------------------------------------------------
		-- GROUP HEADER
		----------------------------------------------------------------
		table.insert(
		result,
		'<tr class="sport-infobox-header">' ..
		'<th colspan="2">' ..
		group.name ..
		'</th></tr>'
		)
		----------------------------------------------------------------
		-- GROUP FIELDS
		----------------------------------------------------------------
		for _, field in ipairs(group.fields) do
			table.insert(
			result,
			'<tr>' ..
			'<th class="sport-infobox-label">' ..
			field.label ..
			'</th>' ..
			'<td class="sport-infobox-value">' ..
			renderValue(field.value) ..
			'</td>' ..
			'</tr>'
			)
		end
	end
	----------------------------------------------------------------
	-- MEDALS
	--
	-- IMPORTANT:
	-- Medals remain INSIDE the infobox table.
	----------------------------------------------------------------
	if box.medals then
		table.insert(
		result,
		'<tr>' ..
		'<td colspan="2" class="sport-infobox-medals">' ..
		box.medals ..
		'</td>' ..
		'</tr>'
		)
	end
	----------------------------------------------------------------
	-- CLOSE TABLE
	----------------------------------------------------------------
	table.insert(
	result,
	'</table>'
	)
	return table.concat(
	result,
	"\n"
	)
end
--------------------------------------------------------------------------------
-- PUBLIC FUNCTION
--------------------------------------------------------------------------------
function p.main(frame)
	----------------------------------------------------------------
	-- GET ARGUMENTS
	----------------------------------------------------------------
	local args =
	getArgs(frame)
	----------------------------------------------------------------
	-- NORMALIZE INPUT
	----------------------------------------------------------------
	args =
	normalize(args)
	----------------------------------------------------------------
	-- ENTITY
	----------------------------------------------------------------
	local entity =
	getEntity(args)
	----------------------------------------------------------------
	-- BUILD INFOBOX
	----------------------------------------------------------------
	local box =
	buildInfobox(
	entity,
	args
	)
	----------------------------------------------------------------
	-- RENDER
	----------------------------------------------------------------
	return renderInfobox(box)
end
--------------------------------------------------------------------------------
-- TEMPLATE ENTRY
--------------------------------------------------------------------------------
function p.infobox(frame)
	return p.main(frame)
end
--------------------------------------------------------------------------------
-- DEBUG FUNCTION
--------------------------------------------------------------------------------
function p.test(frame)
	local args =
	getArgs(frame)
	----------------------------------------------------------------
	-- NORMALIZE
	----------------------------------------------------------------
	args =
	normalize(args)
	----------------------------------------------------------------
	-- ENTITY
	----------------------------------------------------------------
	local entity =
	getEntity(args)
	----------------------------------------------------------------
	-- ENTITY DATA
	----------------------------------------------------------------
	local entityData =
	data.entities[entity]
	if not entityData then
		return "Entity not found: " .. tostring(entity)
	end
	----------------------------------------------------------------
	-- RESULT
	----------------------------------------------------------------
	local result = {}
	table.insert(
	result,
	"Entity: " ..
	entity
	)
	table.insert(
	result,
	"Title: " ..
	tostring(
	entityData.title
	)
	)
	table.insert(
	result,
	"Layouts: " ..
	table.concat(
	entityData.layouts or {},
	", "
	)
	)
	----------------------------------------------------------------
	-- DEBUG TYPE
	----------------------------------------------------------------
	table.insert(
	result,
	"Subtype: " ..
	tostring(
	args.subtype
	or "NOT FOUND"
	)
	)
	----------------------------------------------------------------
	-- DEBUG COACH
	----------------------------------------------------------------
	table.insert(
	result,
	"Coach: " ..
	tostring(
	args.coach
	or "NOT FOUND"
	)
	)
	----------------------------------------------------------------
	-- DEBUG MEDALS
	----------------------------------------------------------------
	table.insert(
	result,
	"Medals: " ..
	tostring(
	args.medaltemplates
	or args.medals
	or "NOT FOUND"
	)
	)
	return table.concat(
	result,
	"\n"
	)
end
--------------------------------------------------------------------------------
-- GET ENTITY LIST
--------------------------------------------------------------------------------
function p.entities()
	local result = {}
	for key, value in pairs(data.entities) do
		table.insert(
		result,
		key ..
		" : " ..
		tostring(
		value.title
		)
		)
	end
	table.sort(result)
	return table.concat(
	result,
	"\n"
	)
end
--------------------------------------------------------------------------------
-- GET VERSION
--------------------------------------------------------------------------------
function p.version()
	return
	data.version.name ..
	" v" ..
	data.version.major ..
	"." ..
	data.version.minor
end
--------------------------------------------------------------------------------
-- EXPORT
--------------------------------------------------------------------------------
return p