Marvel Wiki
Advertisement
Marvel Wiki
4 556
páginas

A documentação para este módulo pode ser criada em Módulo:Design/doc

local p = {}
local h = require("Módulo:HF")
local getArgs = require('Dev:Arguments').getArgs


--------------------------------------------------------------------------------
function p.get_main_border_color()
	return '#B5B7CF'
end

function p.get_main_background_color()
	return '#EFF0FF'
end

--------------------------------------------------------------------------------
function p.green(text)
	local output = ''
	if not h.isempty(text)
		then 
			output = mw.html.create( 'span' )
				:css( 'color', 'darkgreen' )
				:css( 'font-weight', 'bold' )
				:css( 'font-style', 'italic' )
				:css( 'font-size', 'smaller' )
				:wikitext('('..text..')')
				:done()
			output = tostring(output)
	end
	return output
end


--------------------------------------------------------------------------------
function p.span(text)
	local italic = mw.html.create( 'span' ):css( 'font-style', 'italic' )
	local bold = mw.html.create( 'span' ):css( 'font-weight', 'bold' )
	local both = mw.html.create( 'span' ):css( 'font-weight', 'bold' ):css( 'font-style', 'italic' )
	local output = { italic = '', bold = '', both = '' }
	
	if not h.isempty(text)
		then
			output = {
				italic  = tostring(italic:wikitext(text):done()),
				bold	= tostring(bold:wikitext(text):done()),
				both	= tostring(both:wikitext(text):done()),
			}
	end

	return output
end


--------------------------------------------------------------------------------
-- cria caixa de mensagem
function p.messagebox(frame)
	local args = getArgs (frame)
	local width = args['width'] or '95%'
	local textalign = args['text-align'] or 'center'
	local fontsize = args['font-size'] or '100%'
	local border = args['border']
	local background = args['background']
	local margin = args['margin'] or '1em'
	local clear = args['clear'] or 'none'
	local padding = args['padding'] or '5px'
	local extrastyle = args['extrastyle'] or ''
	local message = args[1] or args['Mensagem'] or args['Message'] or ''
	
	local tag = mw.html.create( 'div' )
				:attr( 'id', 'messageBox' )
				:attr( 'align', 'center' )
				:css( 'width', width )
				:css( 'text-align', textalign )
				:css( 'font-size', fontsize )
				:css( 'border', '1px solid' )
				:css( 'border-radius', '10px' )
				:css( 'margin', margin )
				:css( 'clear', clear )
				:css( 'padding', padding )
				:wikitext( message )
				:done()
	if not h.isempty(background)
		then tag:css('background-color', background)
		else tag:addClass('main_background_color')
	end
	
	if not h.isempty(border)
		then tag:css('border-color', border)
		else tag:addClass('main_border_color')
	end
				
	if not h.isempty(extrastyle)
		then tag:cssText (extrastyle):done()
	end
	
	return tostring(tag)
end


--------------------------------------------------------------------------------
-- cria uma caixa de mensagem com aviso de spoiler
function p.aviso_de_spoiler()
	local background = 'rgb(255, 102, 102)'
	local border = 'rgb(255, 20, 20)'
	local extrastyle = 'color: white; clear: both;'
	local header = p.span('Aviso de Spoiler!').bold
	local message = '<br>Esta página pode conter spoilers com detalhes do enredo e/ou finais sobre histórias que foram publicadas ou transmitidas recentemente.<br>'
	message = message..'Por favor, veja nossa [[Marvel Wiki:Spoilers|política de spoiler]] para nossas regras que regem os artigos sobre tais assuntos.'

	return p.messagebox( {Message = header..message, background = background, border = border, extrastyle = extrastyle}) 
end


--------------------------------------------------------------------------------
-- cria uma tabela com as seções "anterior" e "próxima"
function p.table_previous_and_next(message, link_to_previous, link_to_next)
	local td_left = mw.html.create('td')
					:css('width', '10%')
					:css('max-width', '20%')
					:css('text-align', 'left')
	local td_right = mw.html.create('td')
					:css('width', '10%')
					:css('max-width', '20%')
					:css('text-align', 'right')
	local td_left_arrow = mw.html.create('td')
					:css('vertical-align', 'middle')
					:css('font-size', '18px')
					:css('width', '1%')
					:wikitext('←')
	local td_right_arrow = mw.html.create('td')
					:css('vertical-align', 'middle')
					:css('font-size', '18px')
					:css('width', '1%')
					:wikitext('→')
	local td_empty = mw.html.create('td')
					:css('width', '11%')
	local tr = mw.html.create('tr')
	local left = ''
	local right = ''
	local output = mw.html.create('table')
					:css('width', '100%')
			
	if h.isempty(message)
		then message = ''
	end
	message = tostring( mw.html.create('td'):wikitext(message) )
	
	if h.isempty(link_to_previous)
		then left = tostring(td_empty)
		else left = tostring(td_left_arrow)..tostring(td_left:wikitext(link_to_previous))
	end
	if h.isempty(link_to_next)
		then right = tostring(td_empty)
		else right = tostring(td_right:wikitext(link_to_next))..tostring(td_right_arrow)
	end
	tr = tostring( tr:wikitext(left..message..right) )
	output = tostring( output:wikitext(tr) )
			
	return output
end

--------------------------------------------------------------------------------
function p.show_hide(frame)
	local args = getArgs (frame)
	local title = args['title'] or args['header'] or ' '
	local body = args['body'] or args['text'] or ''
	local collapsed = args['collapsed']
	local clear = args['clear'] or 'both'
	local border = args['border']
	local extrastyle = args['extrastyle'] or ''
	local extrastyle2 = args['extrastyle2'] or ''
	local titlestyle = args['titlestyle'] or ''
	local width = args['width'] or '100%'
	local background = args['background']
	local expandtext = args['expandtext'] or 'Expandir'
	local collapsetext = args['collapsetext'] or 'Ocultar'

	if h.isempty(collapsed) or collapsed == 'true' or collapsed == true
		then collapsed = ' mw-collapsed'
		else collapsed = ''
	end

	body = mw.html.create( 'div' )
			:addClass('mw-collapsible-content')
			:css('background-color', 'transparent')
			:wikitext(body)
			:done()
	body = tostring(body)

	title = mw.html.create( 'div' )
			:css('font-weight', 'bold')
			:wikitext(title)
			:done()
	if not h.isempty(background)
		then title:css('background-color', background)
		else title:addClass('main_background_color')
	end
	if not h.isempty(titlestyle)
		then title:cssText (titlestyle):done()
	end
	title = tostring(title)
	
	body = mw.html.create( 'div' )
			:addClass('mw-collapsible'..collapsed)
			:attr('data-expandtext', expandtext)
			:attr('data-collapsetext', collapsetext)
			:css( 'width', width )
			:css( 'border', '1px solid' )
			:css( 'font-size', '12px' )
			:css( 'clear', clear )
			:wikitext(title..body)
			:done()
	if not h.isempty(border)
		then body:css('border-color', border)
		else body:addClass('main_border_color')
	end
	if not h.isempty(extrastyle)
		then body:cssText (extrastyle):done()
	end

	return tostring(body)
end


--------------------------------------------------------------------------------
function p.add_cabecalho(text, nivel, align)
	local output = ''
	nivel = nivel or '2'
	align = align or 'left'
	
	if not h.isempty(text)
		then output = '\n'..tostring( mw.html.create( 'h'..nivel ):css('text-align', align):wikitext( text ) )
	end
	
	return output
end


--------------------------------------------------------------------------------
function p.lua_add_tooltip(text, tooltip)
	local output = mw.html.create('span')
					:css('border-bottom', '1px dotted')
					:css('cursor', 'help')
					:attr('title', tooltip)
					:wikitext(text)
	return tostring(output)
end



--*******************************************************************************************
-- ************* funções para sites relacionados *************
local lista_de_sites = {
	['IMDB']	= {'http://www.imdb.com', 'IMDB.com', 'http://www.imdb.com/title/tt'},
	['AM']		= {'http://www.allmovie.com', 'AllMovie.com', 'http://www.allmovie.com/movie/'},
	['UCM'] 	= {'w:c:pt-br.marvelcinematicuniverse', 'Wiki Universo Cinematográfico Marvel'}, -- https://marvelcinematicuniverse.fandom.com/pt-br/
	['MM']		= {'w:c:marvel-movies', 'Marvel Movies wiki'}, -- https://marvel-movies.fandom.com/wiki/
	['SMF'] 	= {'w:c:spiderman-films', 'Spider-Man Films wiki'}, -- https://spiderman-films.fandom.com/wiki/
	['XM']		= {'w:c:xmenmovies', 'X-Men Movies wiki'}, -- https://xmenmovies.fandom.com/wiki/
}

--------------------------------------------------------------------------------
-- usado em Marvel Wiki:Predefinição de Filme
function p.get_etiqueta_de_site_relacionado(frame)
	local args = getArgs(frame)
	local site = args[1]
	local info = lista_de_sites[site]
	
	if h.in_list({'IMDB', 'AM'}, site)
		then output = 'Em ['..info[1]..' '..info[2]..']'
		else output = 'Em '..h.Link(info[1], info[2])
	end
	
	return output
end


--------------------------------------------------------------------------------
-- usado em Marvel Wiki:Predefinição de Filme
function p.get_link_de_site_relacionado(frame)
	local args = getArgs(frame)
	local site = args[1]
	local link = args[2]
	local text = args[3]
	local info = lista_de_sites[site]
	local output = ''

	if not h.isempty(link)
		then 
			if h.isempty(text)
				then text = link
			end
			if h.in_list({'IMDB', 'AM'}, site)
				then output = '['..info[3]..link..' '..text..']'
				else output = h.Link(info[1]..':'..link, text)
			end
	end
	
	return output
end


--*******************************************************************************************
-- ************* funções para criar INFOBOX *************
--------------------------------------------------------------------------------
-- para ser deletado
function p.criar_infobox(text, width)
	width = width or '250px'
	text = text or ''

	return '__NOEDITSECTION__'..tostring( mw.html.create( 'div' )
		:attr('class', 'infobox')
		:css( 'width', width )
		:css( 'float', 'right' )
		:css( 'clear', 'none' )
		:css( 'margin', '0px 0px 1em 1em' )
		:css( 'border', '1px solid '..p.get_main_border_color() )
		:css( 'background', p.get_main_background_color() )
		:css( 'border-radius', '10px' )
		:css( 'padding', '10px' )
		:wikitext(text)
		:done() )
end


--------------------------------------------------------------------------------
-- para ser deletado
function p.add_infobox_row(label, value)
	local width_l = '40%'
	local width_r = '60%'
	local tag_label
	local tag_value
	local output = ''
	
	if not h.isempty(value)
		then
			if string.find(value, '^\n') == nil
				then value = '\n'..value
			end
			
			tag_label = mw.html.create( 'div' )
				:css( 'width', width_l )
				:css( 'text-align', 'left' )
				:css( 'float', 'left' )
				:css( 'font-weight', 'bold')
				:wikitext(label)
				:done()
			tag_value = mw.html.create( 'div' )
				:css( 'width', width_r )
				:css( 'text-align', 'left' )
				:css( 'float', 'left' )
				:wikitext(value)
				:done()
				
			tag_label = tostring(tag_label)
			tag_value = tostring(tag_value)
			
			output = mw.html.create( 'div' )
				:css( 'border-top', '1px solid '..p.get_main_border_color() )
				:css( 'padding', '2px 0px 2px 0px')
				:css( 'height', '1.5em' )
				:css( 'text-align', 'center' )
				:css( 'clear', 'left' )
				:css( 'font-size', '12px' )
				:wikitext(tag_label..tag_value)
				:done()
			output = tostring(output)
	end

	return output
end


--------------------------------------------------------------------------------
-- para ser deletado
function p.add_infobox_group(group, header)
	local output = ''
	
	if table.concat(group) ~= ''
		then
			header = mw.html.create( 'div' )
			:css( 'clear', 'both' )
				:css( 'text-align', 'center' )
				:css( 'font-weight', 'bold' )
				:css( 'padding', '10px' )
				:css( 'height', '1.5em' )
				:css( 'background', p.get_main_background_color())
				:css( 'font-size', '14px' )
				:wikitext(header)
				:done()
			output = tostring(header)..'\n'..table.concat(group)
	end
	
	return output
end


--------------------------------------------------------------------------------
-- para ser deletado
function p.add_infobox_horizontal_group(frame)
	local args = getArgs (frame)
	local centralheader = args['central_header'] or ''
	local leftheader = args['left_header'] or ''
	local lefttext = args['left_text'] or ''
	local rightheader = args['right_header'] or ''
	local righttext = args['right_text'] or ''
	local totalwidth = args['total_width']
	local tag_centralheader
	local tag_leftheader
	local tag_rightheader
	local tag_lefttext
	local tag_righttext
	local output = ''
 
	if not h.isempty(righttext)
		then 
			if not h.isempty(totalwidth)
				then totalwidth = tostring(tonumber(totalwidth)/2)..'px' 
				else totalwidth = '50%'
			end
		else totalwidth = '100%'
	end

	if not h.isempty(centralheader)
		then
			tag_centralheader = mw.html.create( 'div' )
				:css( 'width', '100%' )
				:css( 'float', 'left' )
				:css( 'font-weight', 'bold')
				:css( 'font-size', '12px' )
				:wikitext(centralheader)
				:done()
			output = output..tostring(tag_centralheader)
		else
			tag_leftheader = mw.html.create( 'div' )
				:css( 'width', totalwidth )
				:css( 'float', 'left' )
				:css( 'font-weight', 'bold')
				:css( 'font-size', '12px' )
				:wikitext(leftheader)
				:done()
			output = output..tostring(tag_leftheader)
	end
 
	if not h.isempty(righttext) and h.isempty(centralheader)
		then
			tag_rightheader = mw.html.create( 'div' )
					:css( 'width', totalwidth )
					:css( 'float', 'left' )
					:css( 'clear', 'right' )
					:css( 'font-weight', 'bold')
					:css( 'font-size', '12px' )
					:wikitext(rightheader)
					:done()
			output = output..tostring(tag_rightheader)
	end
 
	tag_lefttext = mw.html.create( 'div' )
		:css( 'width', totalwidth )
		:css( 'float', 'left' )
		:css( 'clear', 'left' )
		:css( 'font-size', '12px' )
		:wikitext(lefttext)
		:done()
	output = output..tostring(tag_lefttext)
 
 
	if not h.isempty(righttext)
		then
			tag_righttext = mw.html.create( 'div' )
					:css( 'width', totalwidth )
					:css( 'float', 'left' )
					:css( 'text-align', 'center' )
					:css( 'font-size', '12px' )
					:wikitext(righttext)
					:done()
			output = output..tostring(tag_righttext)
	end
 
	return tostring( mw.html.create( 'div' )
		:css( 'border-top', '1px solid '..p.get_main_border_color() )
		:css( 'text-align', 'center' )
		:css( 'clear', 'left' )
		:wikitext(output)
		:done() )
end 


--------------------------------------------------------------------------------
-- para ser deletado
function p.add_titulo_e_imagem_da_pagina_da_infobox(args, pagename, tipo_de_pagina)
	local titulo = args.Titulo or args['Título']
	local nome = args.NomeOficial
	local imagem = args.Imagem or args['Vídeo']
	local tamanho_da_imagem = '250px'
	local texto_da_imagem = args.ImagemTexto or args.TextoDaImagem
	local identidade = ''
	local galeria = ''
	local i
	local output_categories = {}
	local output = ''

	if tipo_de_pagina == 'Personagem'
		then
			nome = args.NomeReal
			identidade = args.IdentidadeAtual
		elseif tipo_de_pagina == 'Raça'
			then nome = args.Nome
	end
	
	if not h.isempty(titulo)
		then output = titulo
		elseif not h.isempty(identidade)
			then output = identidade
		elseif not h.isempty(nome)
			then output = nome
		else output = pagename
	end
	
	if not h.is_link(output) 
		then 
			if h.exists(output..' (Desambiguação)')
				then output = h.Link(output..' (Desambiguação)', output)
				elseif h.exists(output)
					then output = h.Link(output)
			end
	end

	output = mw.html.create('div')
			:css('text-align', 'center')
			:css('font-size', '18px')
			:css('font-weight', 'bold')
			:css('line-height', '2em')
			:wikitext(output)
	output = tostring( output )

	if not h.isempty(tamanho_da_imagem)
		then tamanho_da_imagem = string.gsub(tamanho_da_imagem, 'px', '')..'px'
	end
	if not h.isempty(imagem)
		then 
			imagem = string.gsub(imagem, 'Arquivo:', '')
			if not h.exists('Arquivo:'..imagem)
				then table.insert(output_categories, 'Correção da Imagem de '..tipo_de_pagina..' Necessária')
			end
			if h.in_list({'Nenhuma.jpg', 'Necessária.png'}, imagem)
				then table.insert(output_categories, 'Imagem de '..tipo_de_imagem..' Necessária')
			end

			if imagem ~= 'Nenhuma Imagem Disponível.png'
				then output = output .. '[[Arquivo:'..imagem..'|'..tamanho_da_imagem..'|center]]'
			end
			if not h.isempty(texto_da_imagem) and tipo_de_pagina == 'Funcionário'
				then 
					texto_da_imagem = mw.html.create('span')
								 :css('font-size', '80%')
								 :css('font-family', 'monospace')
								 :wikitext(texto_da_imagem)
					output = output .. tostring(texto_da_imagem)
			end
		else
			table.insert(output_categories, 'Imagem de '..tipo_de_imagem..' Necessária')
	end
	
	if h.pages_in_category(pagename..'/Imagens', 'files') > 0 
	or ( not h.isempty(imagem) and not h.in_list({'Nenhuma.jpg', 'Necessária.png', 'Nenhuma Imagem Disponível.png'}, imagem) )
		then 
			galeria = h.Link(pagename..'/Galeria', 'Galeria')
			if not h.exists(pagename..'/Galeria')
				then table.insert(output_categories, 'Galeria da Página de '..tipo_de_pagina..' Necessária')
			end
			galeria = mw.html.create('div')
						:css('text-align', 'center')
						:css('font-size', '14px')
						:css('font-weight', 'bold')
						:css('font-style', 'italic')
						:css('line-height', '2em')
						:wikitext(galeria)
			output = output .. tostring(galeria)
	end

	return output, output_categories
end


--------------------------------------------------------------------------------
-- para campos com muito texto
function p.add_infobox_row_collapsible(frame)
	local args = getArgs (frame)
	local value = args[1]
	local i
	local j
	local output = ''

	if not h.isempty(value)
		then
			i, j = string.find(string.lower(value), '; anteriormente ') 
			if i ~= nil 
				then output = string.sub(value, 1, i-1) .. '<br>' .. p.show_hide( { title = 'Anteriormente',  body = string.sub(value, j+1, #value) } )
				elseif #value > 500
					then 
						output = p.show_hide( {
						title = '', 
						body = value, 
						collapsed = 'true',
						extrastyle = 'border: none;',
						} )
				else
					output = value
			end
	end

	return output
end


--------------------------------------------------------------------------------
function p.add_titulo_da_pagina_da_infobox(frame)
	local padrao = require("Módulo:NomePadronizado")
	local pagename = mw.title.getCurrentTitle().text
	local classificarnome = ''
	local args = getArgs (frame)
	local tipo_de_pagina = args.tipo_de_pagina
	local titulo = args.Titulo or args['Título'] or args['TítuloDoEpisódio']
	local identidade = args.IdentidadeAtual
	local nome = args.NomeOficial
	local imagem = args.Imagem
	local info
	local output_categories = {}
	local output = ''

	if h.isempty(nome)
		then
			if not h.isempty(args.NomeReal)
				then nome = args.NomeReal
				elseif not h.isempty(args.Nome)
					then nome = args.Nome
			end
	end
	
	if not h.isempty(titulo)
		then output = titulo
		elseif not h.isempty(identidade)
			then output = identidade
		elseif not h.isempty(nome)
			then output = nome
		else output = string.gsub(pagename, ' %(.+%)', '')
	end

	if not h.is_link(output) and h.exists(output)
		then output = h.Link(output)
	end

	if tipo_de_pagina == 'Episódio'
		then output = '"'..string.gsub(output, '"', '')..'"'
	end
	
	-- adicionar nome de classificação padrão
	if tipo_de_pagina == 'Realidade'
		then 
			table.insert(output_categories, 'Realidades')
			classificarnome = '{{DEFAULTSORT:'..require("Módulo:Realidade").get_realidade_info({pagename}).padded_numero..'|noerror}}'
		elseif tipo_de_pagina == 'Personagem'
			then
				table.insert(output_categories, 'Personagens')
				classificarnome = '{{DEFAULTSORT:'..padrao.nome_por_classificacao({pagename})..'|noerror}}'
		elseif tipo_de_pagina == 'Organização'
			then
				table.insert(output_categories, 'Organizações')
				classificarnome = '{{DEFAULTSORT:'..padrao.nome_por_classificacao({pagename})..'|noerror}}'
		elseif tipo_de_pagina == 'Local'
			then
				table.insert(output_categories, 'Locais')
				classificarnome = '{{DEFAULTSORT:'..padrao.nome_por_classificacao({pagename})..'|noerror}}'
		elseif tipo_de_pagina == 'Item'
			then
				table.insert(output_categories, 'Itens')
				classificarnome = '{{DEFAULTSORT:'..padrao.nome_por_classificacao({pagename})..'|noerror}}'
		elseif tipo_de_pagina == 'Série'
			then
				classificarnome = '{{DEFAULTSORT:'..padrao.lua_remove_the(pagename)..'|noerror}}'
		elseif h.in_list({'Filme', 'Novel', 'Vídeo Game'}, tipo_de_pagina) 
			then
				table.insert(output_categories, tipo_de_pagina..'s')
				classificarnome = '{{DEFAULTSORT:'..padrao.lua_remove_the(pagename)..'|noerror}}'
		elseif h.in_list({'Episódio', 'Quadrinho'}, tipo_de_pagina) 
			then
				if tipo_de_pagina == 'Episódio'
					then info = padrao.lua_get_titulo_volume_edicao(pagename, 'Temporada')
					else info = padrao.lua_get_titulo_volume_edicao(pagename, 'Vol')
				end
				if not h.isempty(info.titulo)
					then classificarnome = info.classificarnome.all
					else classificarnome = padrao.lua_remove_the(pagename)
				end
				classificarnome = '{{DEFAULTSORT:'..classificarnome..'|noerror}}__NOTOC__'
				table.insert(output_categories, tipo_de_pagina..'s')
				table.insert(output_categories, info.semedicao)
		else
			table.insert(output_categories, tipo_de_pagina..'s')
			classificarnome = '{{DEFAULTSORT:'..padrao.nome_por_classificacao({pagename})..'|noerror}}'
	end
	
	-- adicionar categorias para a imagem principal
	if not h.isempty(imagem)
		then 
			imagem = string.gsub(imagem, 'Arquivo:', '')
			if not h.exists('Arquivo:'..imagem) -- O campo 'Imagem' está preenchido, mas tal imagem não existe no wiki
				then table.insert(output_categories, 'Correção da Imagem de '..tipo_de_pagina..' Necessária')
			end
			if h.in_list({'Nenhuma.jpg', 'Necessária.png'}, imagem) 
				then table.insert(output_categories, 'Imagem de '..tipo_de_pagina..' Necessária')
			end
		else
			table.insert(output_categories, 'Imagem de '..tipo_de_pagina..' Necessária')
	end
	

	return frame:preprocess(output..classificarnome)..h.add_categories(output_categories)
end

--------------------------------------------------------------------------------
function p.add_infobox_galeria(frame)
	local pagename = mw.title.getCurrentTitle().text
	local args = getArgs (frame)
	local tipo_de_pagina = args.tipo_de_pagina
	local imagem = args.Imagem
	local imagem_texto = args.ImagemTexto or args.TextoDaImagem
	local output_categories = {}
	local output = ''
	
	if tipo_de_pagina ~= 'Funcionário' 
		then
			if	h.pages_in_category(pagename..'/Imagens', 'files') > 0 
			or ( not h.isempty(image) and not h.in_list({'Nenhuma.jpg', 'Necessária.png', 'Nenhuma Imagem Disponível.png'}, imagem) )
				then 
					output = h.Link(pagename..'/Galeria', 'Galeria')
					if not h.exists(pagename..'/Galeria')
						then table.insert(output_categories,  'Página da Galeria de '..tipo_de_pagina..' Necessária')
					end
			end
		elseif not h.isempty(imagem_texto)
			then output = tostring(imagem_texto)			
	end

	return output..h.add_categories(output_categories)
end


-------------------------------------------------------------------------------
function p.add_infobox_nome_oficial(frame)
	local args = getArgs (frame)
	--local tipo_de_pagina = args.tipo_de_pagina
	local nome = args.Nome
	local nome2 = args.Nome2
	local ref = args.NomeRef
	local output = ''
	
	if not h.isempty(args.Nome)
		then 
			nome = args.Nome
			nome2 = args.Nome2
			ref = args.NomeRef
		elseif not h.isempty(args.NomeOficial)
			then
				nome = args.NomeOficial
				nome2 = args.NomeOficial2
				ref = args.NomeOficialRef
		elseif not h.isempty(args.NomeReal)
			then
				nome = args.NomeReal
				nome2 = args.NomeReal2
				ref = args.NomeRealRef	
	end
	
	if h.isempty(nome)
		then output = 'Desconhecido'
		else 
			output = nome
			if not h.is_link(output) and h.exists(output)
				then output = h.Link(output)
			end
	end
	if not h.isempty(nome2)
		then output = output..' '..nome2
	end
	if not h.isempty(ref)
		then output = output..ref
	end

	return output
end

function p.get_nome_original(frame)
	local args = getArgs (frame)
	local value = args.NomeOriginal
	return value
end

--------------------------------------------------------------------------------
function p.add_infobox_primeira_aparicao(frame)
	local padrao = require("Módulo:NomePadronizado")
	local args = getArgs(frame)
	local tipo_de_pagina = args.tipo_de_pagina
	local value = args.Primeira
	local value2 = args.Primeira2
	local estreia
	local output_categories = {}
	local output = {}

	if not h.isempty(value)
		then 
			output, estreia = padrao.lua_get_link_e_data_de_lancamento(value)
			if not h.isempty(estreia)
				then
					estreia = string.match(estreia, '(%d%d%d%d)')
					if estreia ~= nil
						then 
							if not h.isempty(tipo_de_pagina)
								then table.insert(output_categories, 'Estreias de '..tipo_de_pagina..' em '..estreia)
								else table.insert(output_categories, 'Estreias em '..estreia)
							end
					end
			end	
		elseif h.isempty(value2)
			then
				if not h.isempty(tipo_de_pagina)
					then value = 'Primeira Aparição de '..tipo_de_pagina..' Necessária'
					else value = 'Primeira Aparição Necessária'
				end
				table.insert(output_categories, value)
				output = h.LinkToCategory(value, 'Desconhecida')
	end
	if not h.isempty(value2)
		then output = output..value2
	end

	return output..h.add_categories(output_categories)
end


--------------------------------------------------------------------------------
function p.add_infobox_ultima_aparicao(frame)
	local padrao = require("Módulo:NomePadronizado")
	local args = getArgs(frame)
	local ultima_aparicao
	local ultima_aparicao2
	local cabecalho_ultima
	local output = ''

	if not h.isempty(args.Morte) or not h.isempty(args.Morte2)
		then 
			cabecalho_ultima = 'Morte'
			ultima_aparicao = args.Morte
			ultima_aparicao2 = args.Morte2
		elseif not h.isempty(args['Destruição']) or not h.isempty(args['Destruição2'])
			then
			cabecalho_ultima = 'Destruição'
			ultima_aparicao = args['Destruição']
			ultima_aparicao2 = args['Destruição2']
		else
			cabecalho_ultima = 'Última'
			ultima_aparicao  = args['Última']
			ultima_aparicao2 = args['Última2']
	end

	if not h.isempty(args[1])
		then output = cabecalho_ultima
		else
			if not h.isempty(ultima_aparicao)
				then output = padrao.lua_get_link_e_data_de_lancamento(ultima_aparicao)
				else output = ''
			end
			if not h.isempty(ultima_aparicao2)
				then output = output..ultima_aparicao2
			end
	end

	return output
end


--------------------------------------------------------------------------------
function p.add_infobox_criadores(frame)
	local SC = require("Módulo:Correção de Funcionários")
	local args = getArgs(frame)
	local tipo_de_pagina = args.tipo_de_pagina
	local criadores = args.Criadores
	local criadores2 = args.Criadores2
	local output_categories = {}
	local output = ''
	
	if not h.isempty(criadores)
		then output, output_categories = SC.lua_get_criadores(criadores)
		elseif not h.isempty(criadores2)
			then output = output..criadores2
		else table.insert(output_categories, 'Criadores de '..tipo_de_pagina..' Necessários')
	end
	
	return output..h.add_categories(output_categories)
end


--------------------------------------------------------------------------------------------------
function p.add_infobox_identidade(frame)
	local args = getArgs (frame)
	local tipo_de_pagina = args.tipo_de_pagina
	local value = args.Identidade
	local category = ''
	
	if tipo_de_pagina == 'Organização'
		then
	         category = 'Organizações com Identidade '..value
	    end
	    
	if not h.isempty(value)
		then 
			category = tipo_de_pagina..'s com Identidade '..value
			value = h.LinkToCategory(category, value)
			category = h.Category(category)
		else value = ''
	end
	if not h.isempty(args.Identidade2)
		then value = value..' '..args.Identidade2
	end
	
	return value..category
end


--------------------------------------------------------------------------------------------------
function p.add_infobox_status(frame)
	local args = getArgs (frame)
	local value = args.Status
	local tipo_de_pagina = args.tipo_de_pagina
	if tipo_de_pagina == 'Realidade'
		then tipo_de_pagina = 'Realidades'
	elseif tipo_de_pagina == 'Organização'
	    then tipo_de_pagina = 'Organizações'
		else tipo_de_pagina = tipo_de_pagina..'s'
	end
	local output_category = h.Category(tipo_de_pagina..' '..value..'s')
	local output = h.LinkToCategory(tipo_de_pagina..' '..value..'s', value)

	return output..output_category
end


--------------------------------------------------------------------------------------------------
function p.add_infobox_cabecalho_do_grupo_de_membros(frame)
	local pagename = mw.title.getCurrentTitle().text
	local category = pagename..'/Membros'
	local n = h.pages_in_category(category, 'pages')
	local output = 'Membros'
	
	if n > 0
		then output = h.LinkToCategory(category, output)
	end
	
	return output	
end


--------------------------------------------------------------------------------
function p.add_infobox_realidade(frame)
	local modulo_realidade = require("Módulo:Realidade")
	local args = getArgs (frame)
	local tipo_de_pagina = args.tipo_de_pagina
	local pagename = mw.title.getCurrentTitle().text
	local i
	local realidade1 = args.Universo or args.Realidade
	local realidade2 = args.Universo2 or args.Realidade2
	local value
	local category
	local output_categories = {}
	local output = {}

	if h.isempty(realidade1) and h.isempty(realidade2) 
		then 
			if h.in_list({'/Personagens', '/Equipes', '/Organizações'}, tipo_de_pagina)
				then table.insert(output_categories, 'Realidade não especificada')
			end
			if string.find(pagename, '(', 1, true) ~= nil
				then
					_, realidade1 = modulo_realidade.lua_get_nome_e_realidade(pagename)
					realidade1 = realidade1.nome
			end
	end
	
	if not h.isempty(realidade1)
		then 
			if string.find(realidade1, ';') ~= nil
				then 
					realidade1  = mw.text.split(realidade1, ';')
					for i = 1, #realidade1 do
						value = realidade1[i]
						value = modulo_realidade.get_realidade_info({value, 1})
						if value ~= nil
							then
								table.insert(output, h.Link(value))
								table.insert(output_categories, value..tipo_de_pagina)
						end
					end
				else
					value = modulo_realidade.get_realidade_info({realidade1, 1})
					if value ~= nil
						then
							table.insert(output, h.Link(value))
							table.insert(output_categories, value..tipo_de_pagina)
					end
			end
	end
	
	if not h.isempty(realidade2)
		then 
			value = modulo_realidade.get_realidade_info({realidade2, 1})
			if value ~= nil
				then
					table.insert(output, h.Link(value))
					table.insert(output_categories, value..tipo_de_pagina)
				else
					table.insert(output, realidade2)
			end
	end
	
	output = mw.text.listToText(output, ', ', ', ')
	
	return output..h.add_categories(output_categories)
end


--------------------------------------------------------------------------------
function p.add_visaogeral_e_toc(visaogeral)
	local output = '__TOC__'
	
	if not h.isempty(visaogeral)
		then output = visaogeral..'<br>'..output
	end
	
	return output
end


--------------------------------------------------------------------------------
function p.add_citacao(args)
	local output_categories = {}
	local output = ''
	
	if not h.isempty(args.Citacao or args['Citação'])
		then output, output_categories = require("Módulo:Citação").principal(args.FraseCitada or args['Citação'], args.PersonagemCitado or args.Citado, args.FonteDaCitacao or args['FonteDaCitação'] or args['FonteCitação'], true)
	end
	if not h.isempty(args.BlocoDeCitacao or args['BlocoDeCitação'])
		then 
			output = args.BlocoDeCitacao or args['BlocoDeCitação']
			table.insert(output_categories, 'Citações em Bloco')
	end
	
	return output, output_categories
end

--------------------------------------------------------------------------------
-- usado para adicionar seções como "Notas", "Curiosidades", etc.
function p.add_secao(cabecalho, secao, nivel_do_cabecalho)
	local output = ''
	
	nivel_do_cabecalho = nivel_do_cabecalho or 2
	
	if not h.isempty(secao)
		then output = p.add_cabecalho(cabecalho, nivel_do_cabecalho)..'\n'..secao
	end
	
	return output
end


--------------------------------------------------------------------------------
function p.add_secao_historia(args, tipo_de_pagina)
	local value = args['História']
	local value2 = args.TextoDaHistoria or args['TextoDaHistória'] or args['TextoHistória']
	local category = ''
	local output = ''
	
	if h.isempty(value) and h.isempty(value2)
		then category = 'História de '..tipo_de_pagina..' Necessária'
		elseif not h.isempty(value)
			then output = p.add_secao('História', value, 2)
		elseif not h.isempty(value2)
			then output = p.add_secao('História', value2, 2)
	end
	
	return output, category
end


--------------------------------------------------------------------------------
-- uma função para adicionar 'Cotação', seção 'Visão geral', 'Índice' e seção 'História' ao mesmo tempo
function p.add_citacao_visaogeral_toc_historia(args, tipo_de_pagina)
	local value
	local categories = {}
	local output_categories = {}
	local output = {}

	value, categories = p.add_citacao(args)
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)

	table.insert( output, p.add_visaogeral_e_toc(args['VisãoGeral'] or args['Geral']) )
	
	value, categories = p.add_secao_historia(args, tipo_de_pagina)
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)

	return output, output_categories
end


--------------------------------------------------------------------------------
-- uma função para adicionar as seções 'Notas', 'Curiosidades', 'Veja também', 'Leitura recomendada' e 'Links e referências' ao mesmo tempo
function p.add_notas_curiosidades_veja_tambem_recomendado_links_referencias(args, tipo_de_pagina, pagename)
	local value
	local categories = {}
	local output_categories = {}
	local output = {}

	table.insert( output, p.add_secao('Notas', args.Notas, 2) )
	table.insert( output, p.add_secao('Curiosidades', args.Curiosidades, 2) )

	table.insert( output, p.add_cabecalho('Veja também', 2) )
	--adicionar links para subpáginas/categorias padrão - "Aparições", "Aparições Menores", "Menções", "Imagens", "Citações" e "Galeria"
	value, categories = p.add_links_para_subpaginas_padrao(pagename, tipo_de_pagina)
	output_categories = h.join_tables(output_categories, categories)
	output = h.join_tables(output, value)
	
	table.insert( output, p.add_secao('Leitura recomendada', args.Recomendado, 2) )
	
	table.insert( output, p.add_links_e_referencias(args, pagename) )

	return output, output_categories
end


--------------------------------------------------------------------------------
-- usado para adicionar links para subpáginas/categorias padrão - "Aparições", "Aparições", "Menções", "Imagens", "Citações" e "Galeria"
function p.add_links_para_subpaginas_padrao(pagename, tipo_de_pagina)
	local lista_para_realidade = {'Personagens', 'Equipes', 'Organizações', 'Locais', 'Itens', 'Veículos', 'Raças'}
	local s = ''
	local value
	local category
	local output_categories = {}
	local output = {}
	
	value, categories = p.links_para_subcategorias(pagename..'/Aparições', 'pages', pagename, ' aparição(ões) de ', 'Categoria de Aparições de '..tipo_de_pagina..' Necessária')
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)
	
	value, categories = p.links_para_subcategorias(pagename..'/Aparições Menores', 'pages', pagename, ' aparição(ões) menor(es) de ', 'Categoria de Aparições Menores '..tipo_de_pagina..' Necessária')
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)
	
	value, categories = p.links_para_subcategorias(pagename..'/Menções', 'pages', pagename, ' menção(ões) de ', 'Categoria de Menções de '..tipo_de_pagina..' Necessária')
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)

	if tipo_de_pagina == 'Filme' or tipo_de_pagina == 'Episódio'
		then value, categories = p.links_para_subcategorias(pagename..'/Imagens', 'files', pagename, ' imagem(ns) de ', 'Categoria de Imagens de '..tipo_de_pagina..' Necessária')
		else value, categories = p.links_para_subcategorias(pagename..'/Imagens', 'files', pagename, ' imagem(ns) de ', 'Categoria de Imagens de '..tipo_de_pagina..' Necessária')
	end
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)

	value, categories = p.links_para_subcategorias(pagename..'/Citações', 'pages', pagename, ' citação(ões) por ou sobre ', 'Categoria de Citações Necessária')
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)

	value, categories = p.links_para_subcategorias('Morto por '..pagename, 'pages', pagename, ' vítima(s) morta(s) por ', 'Categoria de Morto Por Necessária')
	output_categories = h.join_tables(output_categories, categories)
	table.insert(output, value)

	if tipo_de_pagina == 'Equipe' or tipo_de_pagina == 'Organização'
		then
			value, categories = p.links_para_subcategorias(pagename..'/Membros', 'pages', pagename, ' membro(s) de ', 'Categoria de Membros Necessária')
			output_categories = h.join_tables(output_categories, categories)
			table.insert(output, value)
	end
	
	if tipo_de_pagina == 'Raça' 
		then
			value, categories = p.links_para_subcategorias(string.gsub(pagename, '%(Raça%)', ''), 'pages', pagename, ' representante(s) de ', 'Categoria de Raça Necessária')
			output_categories = h.join_tables(output_categories, categories)
			table.insert(output, value)
	end
	
	if tipo_de_pagina == 'Local' 
		then 
			value, categories = p.links_para_subcategorias(pagename, 'pages', pagename, ' artigo(s) relacionado(s) a ', 'Categoria de Local Necessária')
			output_categories = h.join_tables(output_categories, categories)
			table.insert(output, value)	
	end

	if tipo_de_pagina ~= 'Realidade'
		then
			value, categories = p.links_para_subcategorias(pagename..'/Itens', 'pages', pagename, ' item(ns) usado(s)/pertencente(s) a ', 'Categoria de Itens Necessária')
			output_categories = h.join_tables(output_categories, categories)
			table.insert(output, value)
		else
			for i = 1, #lista_para_realidade do
				s = ' '..string.lower(lista_para_realidade[i])
				value, categories = p.links_para_subcategorias(pagename..'/'..lista_para_realidade[i], 'pages', pagename, s..' que se originaram da(o) ', 'Categoria de '..lista_para_realidade[i]..' Necessária')
				output_categories = h.join_tables(output_categories, categories)
				table.insert(output, value)
			end
	end
	
	return output, output_categories
end


function p.links_para_subcategorias(category, tipos_de_pagina, pagename, text, needed)
	local n = 0
	local output_category = ''
	local output = ''
	
	n = h.pages_in_category(category, tipos_de_pagina)
	if n > 0
		then 
			output = '\n* '..h.LinkToCategory(category, n..text..pagename)
			if not h.exists('Categoria:'..category)
				then output_category = needed
			end
	end

	return output, output_category
end


--------------------------------------------------------------------------------
function p.add_links_e_referencias(args, pagename)
	local value
	local output = {}
	
	table.insert(output, p.add_cabecalho('Links e referências', 2) )

	value = args.Marvel
	if not h.isempty(value)
		then 
			value = '<span class="plainlinks">[http://www.marvel.com/characters/'..value..' '..pagename..' em Marvel.com] <small>(em inglês)</small> </span>'
			table.insert(output, '\n* '..value)
	end
	
	value = args.Wikipedia
	if not h.isempty(value)
		then 
			value = h.Link('Wikipedia:pt:'..value, pagename..' em Wikipedia.org')
			table.insert(output, '\n* '..value)
	end
	
	value = args.OfficialWebsite
	if not h.isempty(value)
		then 
			value = '<span class="plainlinks">['..value..' Site oficial de '..pagename..'] <small>(em inglês)</small></span>'
			table.insert(output, '\n* '..value)
	end

	value = args.Links
	if not h.isempty(value)
		then table.insert(output, '\n'..value)
	end

	table.insert(output, p.add_lista_de_referencias() )

	value = tostring( mw.html.create('span'):attr('id', 'twitter-button') )
	value = mw.html.create('div')
			:css('width', '99%')
			:css('padding', '5px')
			:css('text-align', 'center')
			:css('font-weight', 'bold')
			:css('border-top', '1px solid #AAAAAA')
			:css('border-bottom', '1px solid #AAAAAA')
			:wikitext('Como isso? Nos informe!   '..value)
	table.insert(output, tostring(value))

	return table.concat(output)
end


--------------------------------------------------------------------------------
function p.add_lista_de_referencias()
	local output = mw.html.create('div')
	:css('overflow', 'auto')
	:css('height', 'auto')
	:css('max-height', '250px')
	:css('width', '99%')
	:css('font-size', '12px')
	:css('border', '1px solid #AAAAAA')
	:wikitext('<references group="note" /><references />')

	return p.add_cabecalho('Notas de rodapé', 3)..'\n'..tostring(output)
end

return p
Advertisement