Módulo:Temporada/Partidas

De Clube Atletico Mineiro - Enciclopedia Galo Digital
Ir para navegação Ir para pesquisar

Predefinição:Documentation

Módulo:Temporada/Partidas

O Módulo:Temporada/Partidas define o modelo lógico das partidas de uma temporada e é responsável pela renderização das linhas individuais e da lista completa de jogos no projeto Wiki Galo Digital.

Ele atua como ponte entre os dados brutos da temporada e a apresentação tabular das partidas.

---

Escopo e responsabilidades

Este módulo é responsável por:

  • Criar o objeto lógico Partida
  • Normalizar e validar dados das partidas
  • Calcular resultado do Atlético (V, E, D)
  • Renderizar:
    • Linha individual da tabela de partidas
    • Lista completa de partidas da temporada
  • Centralizar regras de apresentação do placar

Predefinição:Aviso

---

Dependências

Este módulo depende diretamente de:

  • Module:Temporada/Utils

E consome dados exclusivamente de:

  • Module:Temporada/Dados/ANO

---

Estrutura do objeto Partida

O objeto Partida contém os seguintes campos:

  • Identificação
    • id
    • ano
    • data
    • competicao
    • rodada
  • Local
    • estadio
    • localidade
  • Times
    • mandante
    • visitante
  • Placar
    • gols_mandante
    • gols_visitante
  • Autores dos gols
    • autores_mandante
    • autores_visitante
  • Flags de controle
    • wo
    • anulada
    • conta
  • Resultados calculados
    • resultado_mandante
    • resultado_visitante

---

Funções internas

linkTime(nome)

Gera link condicional para nomes de times.

  • Atlético Mineiro é exibido em negrito, sem link
  • Outros times são linkados automaticamente

---

linkarAutores(lista)

Processa lista de autores de gols:

  • Remove contagem do nome do link
  • Preserva sufixos como "(2)", "(3)"
  • Retorna lista formatada e linkada

---

placarExibido(p)

Determina o placar exibido:

  • Considera partidas decididas por W.O
  • Retorna formato padrão "x" quando aplicável

---

renderLinha(p)

Renderiza uma linha completa da tabela de partidas.

Inclui:

  • Súmula
  • Competição
  • Rodada
  • Data
  • Autores dos gols
  • Mandante e visitante
  • Placar com classe CSS
  • Estádio ou localidade

---

Funções públicas

criar(args)

Cria o objeto lógico Partida a partir dos dados brutos.

  • Normaliza parâmetros
  • Aplica validações defensivas
  • Calcula resultados automaticamente

Predefinição:Nota

---

resultadoDoAtletico(p)

Retorna o resultado do Atlético na partida.

  • Identifica se o clube foi mandante ou visitante
  • Retorna V, E ou D

---

renderLista(frame)

Renderiza a lista completa de partidas de uma temporada.

  • Parâmetro
    • frame.args.ano
  • Fluxo
  1. Carrega dados do ano
  2. Cria objetos Partida
  3. Renderiza cada linha
  4. Retorna tabela consolidada

---

obterPorAno(ano)

Obtém a lista de partidas de uma temporada específica.

  • Parâmetro
    • ano
  • Retorno
    • Lista de partidas ou lista vazia

Predefinição:Aviso

---

Regras de validação

  • Partidas anuladas não são contabilizadas
  • Partidas marcadas como não contabilizáveis são ignoradas
  • Campos vazios recebem valores padrão
  • Erros são tratados sem interromper renderização

---

Boas práticas e manutenção

  • Não duplicar lógica de normalização (usar Utils)
  • Manter consistência entre modelo lógico e renderização
  • Alterações no objeto Partida exigem revisão em:
    • Estatísticas
    • Campanhas
    • Templates
  • Novos campos devem ser documentados

---

Páginas relacionadas

---

Histórico

  • Módulo criado para padronizar o tratamento de partidas
  • Centraliza regras de renderização e normalização
  • Projetado para escalabilidade por temporada
-- Module:Temporada/Partidas
-- Modelo lógico + renderização das partidas da temporada
-- Projeto Wiki Galo Digital
--
-- Responsabilidades:
-- - Criar objeto Partida
-- - Renderizar linha individual
-- - Renderizar lista completa a partir dos dados da temporada
--
-- Dependências:
--  - Module:Temporada/Utils

local Utils = require("Module:Temporada/Utils")
local Partidas = {}

--------------------------------------------------
-- LINK CONDICIONAL DE TIME (Atlético sem link)
--------------------------------------------------
local function linkTime(nome)
	nome = Utils.normalizeString(nome)
	if Utils.isAtletico(nome) then
		return "'''" .. nome .. "'''"
	end
	return nome ~= "" and "[[" .. nome .. "]]" or "-"
end

--------------------------------------------------
-- LINKA AUTORES REMOVENDO CONTAGEM DO LINK
--------------------------------------------------
local function linkarAutores(lista)
	if type(lista) ~= "string" then
		return "Não identificado"
	end

	lista = mw.text.trim(lista)
	if lista == "" then
		return "Não identificado"
	end

	if lista == "Não houve" then
		return "Não houve"
	end

	local autores = mw.text.split(lista, ";")
	for i, raw in ipairs(autores) do
		raw = mw.text.trim(raw)

		-- remove "(2)", "(3)" do link
		local nome = mw.ustring.match(raw, "^(.-)%s*%(") or raw
		local sufixo = mw.ustring.match(raw, "%((.-)%)")

		if sufixo then
			autores[i] = "[[" .. nome .. "]] (" .. sufixo .. ")"
		else
			autores[i] = "[[" .. nome .. "]]"
		end
	end

	return table.concat(autores, "; ")
end

--------------------------------------------------
-- CRIA OBJETO PARTIDA (MODELO LÓGICO)
--------------------------------------------------
function Partidas.criar(args)
	local p = {}

	args = args or {}

	p.id = Utils.normalizeString(args.id)
	p.ano = tonumber(args.ano)
	p.data = Utils.normalizeString(args.data)
	p.competicao = Utils.normalizeString(args.competicao)
	p.rodada = Utils.normalizeString(args.rodada)

	p.estadio = Utils.normalizeString(args.estadio)

	-- Localidade (blindagem total contra boolean)
	local loc = ""
	if type(args.localidade) == "string" then
		loc = args.localidade
	elseif type(args["local"]) == "string" then
		loc = args["local"]
	elseif type(args.estadio_local) == "string" then
		loc = args.estadio_local
	end
	p.localidade = Utils.normalizeString(loc)

	p.mandante = Utils.normalizeString(args.mandante)
	p.visitante = Utils.normalizeString(args.visitante)

	p.gols_mandante = Utils.toNumber(args.gols_mandante)
	p.gols_visitante = Utils.toNumber(args.gols_visitante)

	p.autores_mandante = Utils.normalizeString(args.gols_mandante_autores)
	p.autores_visitante = Utils.normalizeString(args.gols_visitante_autores)

	p.wo = Utils.toBoolean(args.wo)
	p.anulada = Utils.toBoolean(args.anulada)
	p.conta = not Utils.toBoolean(args.nao_conta)

	p.resultado_mandante = Utils.resultadoPartida(p.gols_mandante, p.gols_visitante)
	p.resultado_visitante = Utils.resultadoPartida(p.gols_visitante, p.gols_mandante)

	return p
end

--------------------------------------------------
-- RESULTADO DO ATLÉTICO (V/E/D)
--------------------------------------------------
function Partidas.resultadoDoAtletico(p)
	if Utils.isAtletico(p.mandante) then
		return p.resultado_mandante
	elseif Utils.isAtletico(p.visitante) then
		return p.resultado_visitante
	end
	return nil
end

--------------------------------------------------
-- PLACAR EXIBIDO (CONSIDERA W.O)
--------------------------------------------------
local function placarExibido(p)
	if p.wo then
		if Utils.isAtletico(p.mandante) then
			return "O x W"
		elseif Utils.isAtletico(p.visitante) then
			return "W x O"
		end
	end
	return p.gols_mandante .. " x " .. p.gols_visitante
end

--------------------------------------------------
-- RENDERIZA UMA PARTIDA (linha da tabela)
--------------------------------------------------
local function renderLinha(p)
	local resultadoAtl = Partidas.resultadoDoAtletico(p)
	local cssPlacar = Utils.cssResultado(resultadoAtl)

	local autoresMand = (p.gols_mandante == 0)
		and "Não houve"
		or linkarAutores(p.autores_mandante)

	local autoresVisit = (p.gols_visitante == 0)
		and "Não houve"
		or linkarAutores(p.autores_visitante)

	local textoPlacar = placarExibido(p)

	local sumulaTitle = table.concat({
		p.id,
		p.mandante,
		textoPlacar,
		p.visitante
	}, "_"):gsub(" ", "_")

	local linkSumula = "[[" .. sumulaTitle .. "|" .. p.id .. "]]"
	local linkPlacar = "[[" .. sumulaTitle .. "|" .. textoPlacar .. "]]"

	local linkCompeticao = p.competicao ~= "" and "[[" .. p.competicao .. "]]" or "-"
	local estadioNome = p.estadio ~= "" and p.estadio or p.localidade
	local linkEstadio = estadioNome ~= "" and "[[" .. estadioNome .. "]]" or "-"

	return string.format([[
|-
| %s
| %s
| %s
| %s
| %s
| %s
| class="%s gd-score" | %s
| %s
| %s
| class="gd-stadium" | %s
]],
		linkSumula,
		linkCompeticao,
		p.rodada ~= "" and p.rodada or "-",
		p.data ~= "" and p.data or "-",
		autoresMand,
		linkTime(p.mandante),
		cssPlacar,
		linkPlacar,
		linkTime(p.visitante),
		autoresVisit,
		linkEstadio
	)
end

--------------------------------------------------
-- RENDERIZA LISTA COMPLETA DA TEMPORADA
--------------------------------------------------
function Partidas.renderLista(frame)
	local ano = frame.args.ano

	if not ano or ano == "" then
		return "Erro: parâmetro <code>ano</code> não informado."
	end

	local Dados = require("Module:Temporada/Dados/" .. ano)

	local linhas = {}

	for _, args in ipairs(Dados.partidas or {}) do
		local partida = Partidas.criar(args)
		table.insert(linhas, renderLinha(partida))
	end

	return table.concat(linhas)
end

--------------------------------------------------
-- OBTÉM LISTA DE PARTIDAS POR ANO
-- Fonte única: Module:Temporada/Dados/<ano>
--------------------------------------------------
function Partidas.obterPorAno(ano)
	if not ano then
		return {}
	end

	ano = tostring(ano)

	local ok, Dados = pcall(require, "Module:Temporada/Dados/" .. ano)
	if not ok or not Dados or not Dados.partidas then
		return {}
	end

	return Dados.partidas
end


return Partidas
Disponível em “http://www.galodigital.com.br/w/index.php?title=Módulo:Temporada/Partidas&oldid=154188”