Quelltext der Seite Modul:Person/class

local FoundationClass = require('Module:Foundationclass')
local ClassDebug = require('Module:Debug/class')
local ClassSFfield = require('Module:SFfield/class')

-- ****************************************************************
-- *                         inheritance                          *
-- ****************************************************************
local ClassPerson = FoundationClass:subclass('Person')
-- setting class's configuration data
ClassPerson.static.myConfiguration = mw.loadData('Module:Person/config')
--   being in a static method, use self.myConfiguration
--   being in a private method, that knows self or in a public method, use self.class.myConfiguration

-- ****************************************************************
-- *                          properties                          *
-- ****************************************************************

-- **************** initialization of table for private properties
local _private = setmetatable({}, {__mode = 'k'})   -- weak table storing all private attributes

-- **************** declaration of public static properties
-- ClassPerson.static.myPropertyModule = require('Module:extern')
-- ClassPerson.static.staticProperty = ' '

-- remember the static classes provided by Foundationclass:
-- ClassPerson.globalConfig
-- ClassPerson.myCargoUtil
-- ClassPerson.mySmwUtil
-- ClassPerson.myTableTools
-- ClassPerson.myYesno

-- **************** declaration of (global) private properties
-- for properties you should rather use constructor and _private[self]. this only, if you need a private class property
-- you should, however predeclare private methods here
local _abilityParamName	-- used to turn a discipline name into a paramter name
local _debug	-- private method declared later
local _disciplineParamName	-- used to turn a discipline name into a paramter name
local _privateMethodAhead	-- declaration ahead, so this private method can be used in the constructor and in other private methods

-- ***************************************************************
-- *                           methods                           *
-- ***************************************************************
 
-- **************** declaration of static methods
function ClassPerson:initialize(uid, superhandler)
	local _CFG = self.class.myConfiguration
	FoundationClass.initialize(self, uid, superhandler)
	_private[self] = {
		dbg = ClassDebug:new(tostring(self.class) .. ': id ' .. uid),
	}
	_debug(self, 1, ' ClassPerson: done initializing object &quot;' .. uid ..'&quot;, from ' .. tostring(self))
end

-- use use self.myConfiguration to access your configuration in a static method
function ClassPerson.static:aStaticMethod(var)
	_debug(self, 1, 'entering ClassPerson.static:aStaticMethod() to do something, from ' .. tostring(self))
end

function ClassPerson.static:mySfDynamicFieldAttribute(fieldname, attribute, value)
	_debug(self, 1, 'entering ClassPerson.static:mySfDynamicFieldAttribute(fieldname, attribute, value), from ' .. tostring(self))
	_debug(self, 2, ' with parameters &quot;' .. fieldname .. '&quot;, &quot;' .. attribute .. '&quot; and a ' .. type(value) .. ' value')
	-- function that can process any attribute/value pair just before rendering the semantic forms field
	-- usually done, to generate a dynamic 'default' value
	-- keep in mind: you can completely disable a form field, if you return true on attribute &quot;disable&quot;.
	-- 	however, this causes the parameter to not show at all, neither in the form, nor in processing
	local val = value
	if fieldname == 'fullname' and attribute == 'default' then
		val = mw.title.getCurrentTitle().text
	end
	if (fieldname == 'chapter_of_first_appearance' or fieldname == 'died_in_chapter') and attribute == 'default' then
		local query = {
			select = {'[[is_member_of_class::Chapter]]'},
			fields = {'Is_titled'}
		}
		local attributes = {
			limit = 1,
			sort = 'was_written_on',
			order = 'desc',
		}
		local result = ClassPerson.mySmwUtil.ask(query, attributes)
		if result and result[1] and result[1].MainLabel then
			val = result[1].MainLabel
		else
			val = false
		end
	end
	if fieldname == 'disciplines' and attribute == 'show_on_select' then
		val = {}
		local query = {
			select = { '[[Kategorie:Disziplinen]] [[is path of::Nein]]' },
			fields = { 'is path of=path', }
		}
		local attributes = {
			sort = 'has display title',
			order = 'asc',
		}
		local result = ClassPerson.mySmwUtil.ask(query, attributes)
		if result and #result > 0 then
			for _, row in pairs(result) do
				val[row.MainLabel] = _disciplineParamName(self, row.MainLabel)
			end
		end
	end
	if fieldname == 'discipline_nekromantie' and attribute == 'show_on_select' then
		local query = {
			select = { '[[Kategorie:Disziplinen]] [[is path of::Nekromantie]]' },
			fields = { 'is path of=path', }
		}
		local attributes = {
			sort = 'has display title',
			order = 'asc',
		}
		local result = ClassPerson.mySmwUtil.ask(query, attributes)
		if result and #result > 0 then
			val = {}
			for _, row in pairs(result) do
				val[row.MainLabel] = _disciplineParamName(self, row.MainLabel)
			end
		end
	end
	if fieldname == 'discipline_thaumaturgie' and attribute == 'show_on_select' then
		local query = {
			select = { '[[Kategorie:Disziplinen]] [[is path of::Thaumaturgie]]' },
			fields = { 'is path of=path', }
		}
		local attributes = {
			sort = 'has display title',
			order = 'asc',
		}
		local result = ClassPerson.mySmwUtil.ask(query, attributes)
		if result and #result > 0 then
			val = {}
			for _, row in pairs(result) do
				val[row.MainLabel] = _disciplineParamName(self, row.MainLabel)
			end
		end
	end
	return val	-- this value will be used as new value for field's attribute
end

function ClassPerson.static:sfGenerateForm()
	_debug(self, 1, 'entering ClassPerson.static:sfGenerateForm()')
	local _CFG = self.myConfiguration
	local mbox = require('Module:Message box')
	local tagStart = '{{{'
	local tagEnd = '}}}'
	local frame = mw.getCurrentFrame()
	-- create the form header
	local notification = mw.html.create('')
	if _CFG.form.notification and mw.ustring.len(_CFG.form.notification) > 0 then
		notification:wikitext(mbox.main('ombox', { text = _CFG.form.notification }))
			:newline()
	end
	local formheader = mw.html.create('')
	formheader:wikitext(self:sfGenerateFormInfoTag())
		:wikitext('<h2>' .. _CFG.global.entityTitle .. '</h2>')
		:tag('p')
			:wikitext(_CFG.form.headerText)
			:done()
			:newline()
		:node(notification)
		:tag('div')
			:attr('id', 'wikiPreview')
			:cssText('display: none; padding-bottom: 25px; margin-bottom: 25px; border-bottom: 1px solid #AAAAAA;')
			:done()
			:newline()
	-- create the form buttons
	local formbuttons = mw.html.create('div')	-- we have to use a div here. this somehow helps the includes/SF_FormPrinter.php to correcly place the fieldset (blue box) around the form
	if FoundationClass.myTableTools.inTable(_CFG.form.buttons, 'summary') then
		formbuttons:tag('p')
			:wikitext(tagStart .. 'standard input&#124;summary' .. tagEnd)
			:done()
			:newline()
	end
	for _, button in pairs(_CFG.form.buttons) do
		if button ~= 'summary' then
			formbuttons:wikitext(tagStart .. 'standard input&#124;' .. button .. tagEnd)
		end
	end
	formbuttons:addClass('formbuttons')
		:done()
	-- assemble everything
	-- start the html object
	local html = mw.html.create('div')	-- we need this div, otherwise the embedded template will fail
	html:node(formheader)
		:wikitext('__NOGLOSSARY__<h1>Personendaten</h1>')
		:newline()
		:wikitext(tagStart .. 'for template|' .. _CFG.template.name .. '|label=' .. _CFG.global.entityTitle .. tagEnd)
		:newline()
		:node(self:sfGenerateFormTable(_CFG.form.tab_maindata))
		:wikitext('<h1>Fähigkeiten</h1>')
		:newline()
		:node(self:sfGenerateFormTableAbilities())
		:newline()
		:wikitext('<h1>Weitere Informationen</h1>')
		:newline()
		:node(self:sfGenerateFormTable(_CFG.form.tab_information))
		:newline()
		:wikitext(frame:extensionTag('headertabs'))
		:newline()
		:wikitext("'''(*) Pflichtfeld'''")
		:newline()
		:wikitext(tagStart .. 'end template' .. tagEnd)
		:newline()
		:node(formbuttons)
	local debugLevel = FoundationClass.globalConfig.debugLevel or self.myConfiguration.global.debugLevel
	if debugLevel then
		html:newline()
			:newline()
			:wikitext(ClassDebug:printLog(debugLevel))
	end
	return html
end

function ClassPerson.static:sfGenerateFormTableAbilities()
	_debug(self, 1, 'entering ClassPerson.static:sfGenerateFormTableAbilities()')
	local _CFG = self.myConfiguration
	ClassSFfield:setDefaultSize(_CFG.form.fieldSize)
	ClassSFfield:setDefaultTextAreaCols(_CFG.form.textareaAttributes.cols)
	ClassSFfield:setDefaultTextAreaEditor(_CFG.form.textareaAttributes.editor)
	ClassSFfield:setDefaultTextAreaRows(_CFG.form.textareaAttributes.rows)
	local abilities = {}
	local fieldlist = {'abilities', 'disciplines'}
	local fielddata = {
		abilities = _CFG.parameter.abilities,
		disciplines = _CFG.parameter.disciplines,
	}
	local fieldlist_helper = {}
	local query = {
		select = { '[[Is member of class::DisciplineAbility]]' },
		fields = { 'Has ability name=name', 'Is associated to page=page'}
	}
	local attributes = {
		sort = 'Is associated to page,Has_level,Has ability name',
		order = 'asc,asc,asc',
	}
	local result = ClassPerson.mySmwUtil.ask(query, attributes)
	if result and #result > 0 then
		for _, row in pairs(result) do
			if not abilities[row.page] then
				abilities[row.page] = {row.name}
			else
				table.insert(abilities[row.page], row.name)
			end
		end
	end
	local query = {
		select = { '[[Kategorie:Disziplinen]]' },
		fields = { 'is path of=path', }
	}
	local attributes = {
		sort = 'has display title',
		order = 'asc',
	}
	local result = ClassPerson.mySmwUtil.ask(query, attributes)
	if result and #result > 0 then
		for _, row in pairs(result) do
			fieldname = _disciplineParamName(self, row.MainLabel)
			if row.MainLabel == 'Thaumaturgie' or row.MainLabel == 'Nekromantie' then
				fielddata[fieldname] = _CFG.parameter[fieldname]
			else
				fielddata[fieldname] = {
					cardinality = 'list',
					description = 'Auf welche Ränge/Fähigkeiten hat die Person Zugriff in dieser Disziplin?',
					label = row.MainLabel,
					severity = 'suggested',
					sf = {
						delimiter='~',
						input_type = 'checkboxes',
						mapping_property = 'Has_ability_name',
						values = abilities[row.MainLabel],
					},
					td_type = 'line',
				}
			end
			local fieldlist_helper_index = _disciplineParamName(self, row.path)
			if not fieldlist_helper[fieldlist_helper_index] then
				fieldlist_helper[fieldlist_helper_index] = {fieldname}
			else
				table.insert(fieldlist_helper[fieldlist_helper_index], fieldname)
			end
		end
	end
	local startIndex = _disciplineParamName(self, 'Nein')
	if fieldlist_helper[startIndex] and #fieldlist_helper[startIndex] > 0 then
		for _, fname in pairs(fieldlist_helper[startIndex]) do
			table.insert(fieldlist, fname)
			if fieldlist_helper[fname] then
				for _, fname2 in pairs(fieldlist_helper[fname]) do
					table.insert(fieldlist, fname2)
				end
			end
		end
	end
	-- now generate the table
	-- now create the form table
	local hidden = mw.html.create('')
	local formtable = mw.html.create('table')
	for _, fieldname in pairs(fieldlist) do
		if fielddata[fieldname] and not self:mySfDynamicFieldAttribute(fieldname, 'disable', false)  then
			local field = self:sfInitFieldAbility(fieldname, fielddata[fieldname])
			if field then
				if field:get('hidden') then
					hidden:wikitext(field:render())
				else
					formtable:node(field:createTr(fielddata[fieldname].label, fielddata[fieldname].description))
				end
			end
		end
	end
	formtable:addClass(FoundationClass.globalConfig.formTableClass)
		:css('width', 'auto')
	if tableid then
		formtable:attr('id', tableid)
	end
	formtable:done()
		:node(hidden)
--[[		:wikitext('<h3>table fieldlist</h3>')
		:tag('pre')
			:wikitext(FoundationClass.myTableTools.printTable(fieldlist))
			:done()
		:wikitext('<h3>table fieldlist_helper</h3>')
		:tag('pre')
			:wikitext(FoundationClass.myTableTools.printTable(fieldlist_helper))
			:done()
		:wikitext('<h3>table fielddata</h3>')
		:tag('pre')
			:wikitext(FoundationClass.myTableTools.printTable(fielddata))
			:done()
			--]]
	return formtable
end

function ClassPerson.static:sfInitFieldAbility(fieldname, fielddata)
	_debug(self, 1, 'entering ClassPerson.static:sfInitFieldAbility(fieldname) to initialize field ' .. fieldname or 'NOT SET' .. ', from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local field
	if fieldname and fielddata and fielddata.sf and not self:mySfDynamicFieldAttribute(fieldname, 'disable', false) then
		field = ClassSFfield:new(fieldname)
		if fielddata.cardinality and fielddata.cardinality == 'list' then
			field:set('list', self:mySfDynamicFieldAttribute(fieldname, 'list', true))
			local delimiter = fielddata.sf and fielddata.sf.delimiter or _CFG.global.delimiter
			-- if we have a global or local delimiter set which is not the comma (','), provide it here automatically
			if delimiter ~= ',' then
				field:set('delimiter', self:mySfDynamicFieldAttribute(fieldname, 'delimiter', delimiter))
			end
		end
		if fielddata.severity and fielddata.severity == 'mandatory' then
			field:set('mandatory', self:mySfDynamicFieldAttribute(fieldname, 'mandatory', true))
		end
		if fielddata.values then
			field:set('values', self:mySfDynamicFieldAttribute(fieldname, 'values', fielddata.values))
		end
		if fielddata.sf then
			for attr, val in pairs(fielddata.sf) do
				field:set(mw.ustring.gsub(attr, '_', ' '),
						self:mySfDynamicFieldAttribute(fieldname, attr, val)	-- remember: self refers to a class, not an object and this method is static
					)
			end
		end
	end
	return field
end

-- **************** declaration of private methods
-- use self.class.myConfiguration to access your configuration in a public or a private method that is called by a public method

_debug = function (self, level, text)
	if _private[self] and _private[self].dbg then
		local debugLevel = FoundationClass.globalConfig.debugLevel or self.class.myConfiguration.global.debugLevel
		if debugLevel and level <= debugLevel then
			_private[self].dbg:log(level, text)
		end
	else
		local debugLevel = FoundationClass.globalConfig.debugLevel or self.myConfiguration.global.debugLevel
		if debugLevel and level <= debugLevel then
			ClassDebug:log(level, text, tostring(self) .. '.static')
		end
	end
end

_disciplineParamName = function (self, discipline)
	return 'discipline_' .. mw.uri.anchorEncode(mw.ustring.gsub(mw.ustring.lower(discipline), '[äöüß]', ''))
end

local _privateMethod = function (self)
	_debug(self, 1, 'entering private _privateMethod() to do something, from ' .. tostring(self))
end

-- **************** declaration of public methods
-- use self.class.myConfiguration to access your configuration in a public method
function ClassPerson:addInfobox()
	_debug(self, 1, 'entering ClassPerson:addInfobox(), from ' .. tostring(self))
	if self:goodToGo() then
		local _CFG = self.class.myConfiguration
		local coreData = self:getCoreData()
		local name = coreData.fullname or coreData.displayname
		local haven
		if coreData.haven and #coreData.haven > 0 then
			haven = {}
			for _, h in pairs(coreData.haven) do
				table.insert(haven, ClassPerson:formRedlink(h, 'Schauplatz'))
			end
		end
		local disciplines
		if coreData.capabilies and #coreData.capabilies > 0 then
			local main = {}
			for _, discipline in pairs(coreData.capabilies) do
				local str = '[[' .. discipline .. ']]'
				if coreData.capabilies_data[discipline] then
					if coreData.capabilies_data[discipline].rank and coreData.capabilies_data[discipline].rank > 0 then
						str = str .. ' (' .. coreData.capabilies_data[discipline].rank .. ')'
					end
					if coreData.capabilies_data[discipline].paths and #coreData.capabilies_data[discipline].paths > 0 then
						local _sub = {}
						for _, _path in pairs(coreData.capabilies_data[discipline].paths) do
							local str2 = '[[' .. _path .. ']]'
							if coreData.capabilies_data[discipline].path_data[_path] and coreData.capabilies_data[discipline].path_data[_path].rank and coreData.capabilies_data[discipline].path_data[_path].rank > 0 then
								str2 = str2 .. ' (' .. coreData.capabilies_data[discipline].path_data[_path].rank .. ')'
							end
							table.insert(_sub, str2)
						end
						str = str .. ' 	&#91;' .. mw.text.listToText(_sub, ', ', ' und ') .. '&#93;'
					end
				end
				table.insert(main, str)
			end
			disciplines = mw.text.listToText(main, ', ', ' und ')
		end
		
		local ib_args = {
			bodyclass = 'infobox_person',
			titleclass = 'objtitle titletext',
			aboveclass = 'headertext typ_' .. mw.ustring.lower(coreData.type),
			headerclass = 'headertext typ_' .. mw.ustring.lower(coreData.type),
			labelstyle = 'width: 40%;',
			datastyle = 'width: 60%;',
			title = name,
			above = coreData.type,
			image = coreData.image and '[[' .. coreData.image ..'|300px|' .. name .. ']]' or '[[Bild:NoCharPic.png|300px|Kein Bild vorhanden]]',
			caption = coreData.displayname,
			label1 = _CFG.parameter.coterie.label,
			data1 = (ClassPerson.myYesno(coreData.coterie) and 'Ja' or 'Nein'),
			label2 = _CFG.parameter.sect.label,
			data2 = coreData.sect and '[[' .. coreData.sect .. ']]' or (coreData.type == 'Vampir' and 'unbekannt' or nil),
			label3 = _CFG.parameter.clan.label,
			data3 = coreData.clan and ClassPerson:formRedlink(coreData.clan, 'Clan') .. (ClassPerson.myYesno(coreData.antitribu) and ' antitribu' or '') or (coreData.type == 'Vampir' and 'unbekannt' or nil),
			label5 = _CFG.parameter.sire.label,
			data5 = coreData.sire and ClassPerson:formRedlink(coreData.sire, 'Person') or (coreData.type == 'Vampir' and 'unbekannt' or nil),
			label6 = _CFG.parameter.generation.label,
			data6 = coreData.generation and coreData.generation or (coreData.type == 'Vampir' and 'unbekannt' or nil),
			label7 = _CFG.parameter.original_generation.label,
			data7 = coreData.original_generation and coreData.original_generation or nil,
			label8 = _CFG.parameter.embraced.label,
			data8 = coreData.embraced and (ClassPerson.myYesno(coreData.embraced_is_estimate) and 'um ' or '') .. coreData.embraced or (coreData.type == 'Vampir' and 'unbekannt' or nil),
			label9 = _CFG.parameter.apparent_age.label,
			data9 = coreData.apparent_age and coreData.apparent_age or nil,
			label13 = _CFG.parameter.residence.label,
			data13 = coreData.residence and ClassPerson:formRedlink(coreData.residence, 'Stadt') or nil,
			label14 = _CFG.parameter.office.label,
			data14 = coreData.office and coreData.office or nil,
			label15 = _CFG.parameter.haven.label,
			data15 = haven and mw.text.listToText(haven, ', ', ' und ') or nil,
			label17 = _CFG.parameter.chapter_of_first_appearance.label,
			data17 = coreData.chapter_of_first_appearance and '[[' .. coreData.chapter_of_first_appearance .. ']]' or nil,
			label18 = _CFG.parameter.died_in_chapter.label,
			data18 = coreData.died_in_chapter and '[[' .. coreData.died_in_chapter .. ']]' or nil,
			label22 = 'Bekannte Kinder',
			data22 = (coreData.children and #coreData.children > 0) and '[[' .. mw.text.listToText(coreData.children, ']], [[', ']] und [[') ..']]' or nil,
			label23 = 'Bekannte Ghule',
			data23 = (coreData.ghuls and #coreData.ghuls > 0) and '[[' .. mw.text.listToText(coreData.ghuls, ']], [[', ']] und [[') ..']]' or nil,
			label24 = 'Disziplinen',
			data24 = disciplines,
			header26 = 'Through the looking glass',
			label27 = 'Figurentyp',
			data27 = coreData.coterie and 'SC' or 'NSC',
			label28 = _CFG.parameter.player.label,
			data28 = coreData.player and coreData.player or nil,
			label29 = 'Spielteilnahmen',
			data29 = coreData.history and #coreData.history or nil,
		}
		self:addOutput(require('Module:Infobox').infobox(ib_args))
		return true
	end
	return false
end

function ClassPerson:addPageBody()
	_debug(self, 1, 'entering ClassPerson:addPageBody(), from ' .. tostring(self))
	_debug(self, 2, ' rendering errors and warnings and adding them to output')
	local frame = mw.getCurrentFrame()
	local coreData = self:getCoreData()
	-- this is used in conjunction with the extension CSS and the parser function #css to disable the virtual editor on person pages
	local css = [==[
#ca-ve-edit {
  display: none !important;
}
]==]
	frame:callParserFunction('#css:' .. css)
	self:addOutput(self:renderErrors())
	self:addOutput(self:renderWarnings())
	self:setSortkey(coreData.displayname)
	if self:goodToGo() then
		local section_htmls = {}
		if coreData.introtext then
			section_htmls.introtext = coreData.introtext .. '\n'
		end
		-- assemble character history
		local history = mw.html.create('')
		history:wikitext('<h2>Werdegang</h2>')
			:newline()
		if coreData.history and #coreData.history > 0 then
			for _, data in pairs(coreData.history) do
				history:wikitext('* ' .. ClassPerson:formRedlink(data.place, 'Stadt') .. ', ' .. data.begin .. (data['end'] and ' - ' .. data['end'] or '') .. ': [[' .. data.MainLabel .. ']] (' .. data.description .. ')')
					:newline()
			end
		else
			history:wikitext('keine Daten vorliegend')
				:newline()
		end
		section_htmls.history = history
		-- display the mentions in texts
		if coreData.mentions and #coreData.mentions > 0 then
			local mentions = mw.html.create('')
			mentions:wikitext('<h2>Textuelle Erwähnungen</h2>')
				:newline()
			for _, data in pairs(coreData.mentions) do
				mentions:wikitext('* [[' .. data.MainLabel .. ']] (Quelle: [[' .. data.source .. ']], Beschreibung: ' .. data.description .. ')')
					:newline()
			end
			section_htmls.mentions = mentions
		end
		-- gather all infos added in chapters for this person
		local sections = {'Hintergrund', 'Fähigkeiten', 'Verbindungen', 'Agenda', 'Kommentare'}
		local sections2params = {
			Hintergrund = 'background',
			Verbindungen = 'relations',
			Agenda = 'agenda',
			Kommentare = 'comments',
		}
		sections2params['Fähigkeiten'] = 'abilities'
		for _, section in pairs(sections) do
			local payload
			if coreData[sections2params[section]] then
				payload = coreData[sections2params[section]] .. '\n'
			end
			if coreData.information[section] and #coreData.information[section] > 0 then
				if payload then
					payload = payload .. '\n<b>Automatisch hinzugefügt:</b><br>\n'
				else
					payload = ''
				end
				for _, info in pairs(coreData.information[section]) do
					payload = payload .. '* ' .. info.payload .. ' (Quelle: [[' .. info.source .. ']], siehe auch [[' .. info.page .. ']])\n'
				end
			end
			if not payload or #payload == 0 then
				payload = 'Keine Informationen vorliegend'
			end
			local element = mw.html.create('')
			element:wikitext('<h2>' .. section .. '</h2>')
				:newline()
				:wikitext(payload)
				:newline()
			section_htmls[sections2params[section]] = element
		end
		-- lets check, if we have to add someting to the abilities section
		if coreData.capabilies and #coreData.capabilies > 0 then
			local ClassDisciplineAbility = require('Modul:Discipline/ability/class')
			local html = mw.html.create('')
			for _, discipline in pairs(coreData.capabilies) do
				local headline = discipline
				if coreData.capabilies_data[discipline] and coreData.capabilies_data[discipline].rank and coreData.capabilies_data[discipline].rank > 0 then
					headline = headline .. ' (' .. coreData.capabilies_data[discipline].rank .. ')'
				end
				html:wikitext('<h3>' .. headline .. '</h3>')
					:newline()
				-- now we have either abilities for that discipline or we have paths
				if coreData.capabilies_data[discipline] and coreData.capabilies_data[discipline].abilities and #coreData.capabilies_data[discipline].abilities > 0 then
					for _, ability in pairs(coreData.capabilies_data[discipline].abilities) do
						html:wikitext('<h4>rendering ability ' .. ability .. '</h3>')
							:newline()
					end
				else
					html:wikitext('Keine Disziplinfähigkeiten hinterlegt.')
						:newline()
						:tag('small')
							:wikitext('Um Disziplinfähigkeiten zu hinterlegen, bitte die Seite per Formular bearbeiten und auf dem Reiter \'\'Fähigkeiten\'\' im Feld \'\''
								.. discipline .. '\'\' gewünschte Fähigkeiten aktivieren!' )
							:done()
				end
				if coreData.capabilies_data[discipline] and coreData.capabilies_data[discipline].paths and #coreData.capabilies_data[discipline].paths > 0 then
					for _, _path in pairs(coreData.capabilies_data[discipline].paths) do
						local headline2 = _path
						if coreData.capabilies_data[discipline].path_data[_path] and coreData.capabilies_data[discipline].path_data[_path].rank and coreData.capabilies_data[discipline].path_data[_path].rank > 0 then
							headline2 = headline2 .. ' (' .. coreData.capabilies_data[discipline].path_data[_path].rank .. ')'
						end
						html:wikitext('<h4>' .. headline2 .. '</h3>')
							:newline()
						if coreData.capabilies_data[discipline].path_data[_path] and coreData.capabilies_data[discipline].path_data[_path].abilities and #coreData.capabilies_data[discipline].path_data[_path].abilities > 0 then
							for _, ability in pairs(coreData.capabilies_data[discipline].path_data[_path].abilities) do
								html:wikitext('<h5>rendering ability ' .. ability .. '</h3>')
									:newline()
							end
						end
					end
				end
			end
			section_htmls.abilities:node(html)
		end
			
		--[==[
				local disciplines
		if coreData.capabilies and #coreData.capabilies > 0 then
			local main = {}
			for _, discipline in pairs(coreData.capabilies) do
				local str = '[[' .. discipline .. ']]'
				if coreData.capabilies_data[discipline] then
					if coreData.capabilies_data[discipline].rank and coreData.capabilies_data[discipline].rank > 0 then
						str = str .. ' (' .. coreData.capabilies_data[discipline].rank .. ')'
					end
					if coreData.capabilies_data[discipline].paths and #coreData.capabilies_data[discipline].paths > 0 then
						local _sub = {}
						for _, _path in pairs(coreData.capabilies_data[discipline].paths) do
							local str2 = '[[' .. _path .. ']]'
							if coreData.capabilies_data[discipline].path_data[_path] and coreData.capabilies_data[discipline].path_data[_path].rank > 0 then
								str2 = str2 .. ' (' .. coreData.capabilies_data[discipline].path_data[_path].rank .. ')'
							end
							table.insert(_sub, str2)
						end
						str = str .. ' 	&#91;' .. mw.text.listToText(_sub, ', ', ' und ') .. '&#93;'
					end
				end
				table.insert(main, str)
			end
			disciplines = mw.text.listToText(main, ', ', ' und ')
		end
--]==]
		
		local testing = mw.html.create('')
		testing:wikitext('<h3>possesses_ability</h3>')
			:tag('pre')
				:wikitext((coreData.possesses_ability and ClassPerson.myTableTools.printTable(coreData.possesses_ability) or 'NIL'))
				:done()
			:wikitext('<h3>capabilies</h3>')
			:tag('pre')
				:wikitext((coreData.capabilies and ClassPerson.myTableTools.printTable(coreData.capabilies) or 'NIL'))
				:done()
			:wikitext('<h3>capabilies_data</h3>')
			:tag('pre')
				:wikitext((coreData.capabilies_data and ClassPerson.myTableTools.printTable(coreData.capabilies_data) or 'NIL'))
				:done()
			:wikitext('<h3>coreData</h3>')
			:tag('pre')
				:wikitext((coreData and ClassPerson.myTableTools.printTable(coreData) or 'NIL'))
				:done()
		--self:addOutput(testing)
		
		self:addOutput(section_htmls.introtext)
		self:addOutput(section_htmls.background)
		self:addOutput(section_htmls.history)
		self:addOutput(section_htmls.mentions)
		self:addOutput(section_htmls.relations)
		self:addOutput(section_htmls.abilities)
		self:addOutput(section_htmls.agenda)
		self:addOutput(section_htmls.comments)
		
		local navbox = require('Module:Navbox')._navbox
		local arguments = {
			navbar = 'off',
			title = 'Personen',
			state = 'expanded',
			group1 = 'Klüngelmitglieder',
			list1 = '[[' .. table.concat(coreData.pcs, ']]&nbsp;&nbsp;&nbsp;&nbsp;&bull;&emsp;[[') ..']]',
--			list1 = '[[' .. mw.text.listToText(coreData.pcs, ']], [[', ']] und [[') ..']]',
			group2 = 'Weitere Personen',
			list2 = '[[' .. table.concat(coreData.npcs, ']]&nbsp;&nbsp;&nbsp;&nbsp;&bull;&emsp;[[') ..']]',
--			list2 = '[[' .. mw.text.listToText(coreData.npcs, ']], [[', ']] und [[') ..']]',
		}
		if coreData.clanmember and #coreData.clanmember > 0 then
			arguments.group3 = arguments.group2
			arguments.list3 = arguments.list2
			arguments.group2 = 'Bekannte ' .. coreData.clan
			arguments.list2 = '[[' .. table.concat(coreData.clanmember, ']]&nbsp;&nbsp;&nbsp;&nbsp;•&emsp;[[') ..']]'
--			arguments.list2 = '[[' .. mw.text.listToText(coreData.clanmember, ']], [[', ']] und [[') ..']]'
		end
		self:addOutput(navbox(arguments))
		return true
	end
	return false
end

function ClassPerson:myArgumentProcessing(coreData)
	_debug(self, 1, 'entering ClassPerson:myArgumentProcessing(args) to process coreData, from ' .. tostring(self))
	-- function that performs some individual transformation args --&amp;gt; coreData
	-- remember: you can add warnings to your output with self:addWarning(warning). the page, however, will not be put in any gardening category. for that, use self:addError()
	-- hint: for conversion bool values, this is useful: FoundationClass.myYesno
	local coreData = coreData
	if not coreData.displayname then
		coreData.displayname = self:getUid()
	end
	coreData.displaytitle = coreData.displayname
	if not coreData.type then
		coreData.type = 'Vampir'
	end
	if not coreData.image then
		coreData.image = 'Bild:NoCharPic.png'
	else
		if mw.ustring.find(coreData.image, ':') then
			coreData.image = mw.ustring.match(coreData.image, '^.*:([^:]+)$')
		end
		coreData.image = 'Bild:' .. coreData.image
	end
	if not coreData.coterie then
		coreData.coterie = false
	end
	-- the following antitribu calculate should be done dynamically later (once, clans are in the system)
	if coreData.sect and coreData.clan then
		local sects = {
			Assamiten = 'Unabhängig',
			Brujah = 'Camarilla',
			Caitiff = 'Camarilla',
			Gangrel = 'Unabhängig',
			Giovanni = 'Unabhängig',
			Kappadozianer = 'Unabhängig',
			Kyasid = 'Sabbat',
			Lasombra = 'Sabbat',
			Malkavianer = 'Camarilla',
			Nosferatu = 'Camarilla',
			Pander = 'Sabbat',
			Ravnos = 'Unabhängig',
			Salubri = 'Sabbat',
			Toreador = 'Camarilla',
			Tremere = 'Camarilla',
			Tzimisce = 'Sabbat',
			Ventrue = 'Camarilla',
		}
		sects['Harbinger of Skulls'] = 'Sabbat'
		sects['Jünger des Set'] = 'Unabhängig'
		if sects[coreData.clan] == coreData.sect then
			coreData.antitribu = 'Nein'
		else
			coreData.antitribu = 'Ja'
		end
	end
	-- get all persons in the system (for the navbox, the ghuls, the children, ...)
	local children = {}
	local clanmember = {}
	local ghuls = {}
	local npcs = {}
	local pcs = {}
	local query = {
		select = { '[[is_member_of_class::Person]]' },
		fields = { 'is_of_character_type=type', 'was_sired_by=sire', 'is_member_of_the_coterie=coterie', 'is_member_of_clan=clan' }
	}
	local attributes = {
		sort = 'has display title',
		order = 'asc',
	}
	local result = ClassPerson.mySmwUtil.ask(query, attributes)
	if result then
		for _, data in pairs(result) do
			if data.sire == self:getUid() then
				if data.type == 'Vampir' then
					table.insert(children, data.MainLabel)
				elseif data.type == 'Ghul' then
					table.insert(ghuls, data.MainLabel)
				end
			end
			if ClassPerson.myYesno(data.coterie) then
				table.insert(pcs, data.MainLabel)
			else
				table.insert(npcs, data.MainLabel)
			end
			if coreData.clan and coreData.clan == data.clan then
				table.insert(clanmember, data.MainLabel)
			end
		end
	end
	if #children == 0 then
		children = nil
	end
	if #ghuls == 0 then
		ghuls = nil
	end
	coreData.children = children
	coreData.clanmember = clanmember
	coreData.ghuls = ghuls
	coreData.npcs = npcs
	coreData.pcs = pcs
	-- now get the characters story
	local query = {
		select = { '[[is_member_of_class::Chapter]]', '[[has cast::' .. self:getUid() .. ']]' },
		fields = { 'Took_place_on=begin', 'Took_place_until=end', 'Took_place_in=place', 'Is_titled=title', 'Has_short_description=description' }
	}
	local attributes = {
		sort='has_chapter_number,has_subchapter_number',
		order = 'asc,asc',
	}
	coreData.history = ClassPerson.mySmwUtil.ask(query, attributes)
	-- get all mentions in texts
	local query = {
		select = { '[[is_member_of_class::Text]]', '[[concerns::' .. self:getUid() .. ']]' },
		fields = { 'has source=source', 'Has_short_description=description' }
	}
	local attributes = {
		sort='has_display_title',
		order = 'asc',
	}
	coreData.mentions = ClassPerson.mySmwUtil.ask(query, attributes)
	-- and all the information available about this person
	local query = {
		select = { '[[is_member_of_class::Info]]', '[[concerns::' .. self:getUid() .. ']]' },
		fields = { 'has_source=source', 'holds_information=payload', 'is_about=type', 'is_associated_to_page=page' }
	}
	local result = ClassPerson.mySmwUtil.ask(query, {})
	local information = {}
	if result and #result > 0 then
		for _, data in pairs(result) do
			if not information[data.type] then
				information[data.type] = {}
			end
			table.insert(information[data.type], data)
		end
	end
	coreData.information = information
	-- lets see, if the character has any abilities entered
	local possesses_ability = {}
	local capabilies
	local capabilies_data = {}
	if coreData.disciplines and #coreData.disciplines > 0 then
		capabilies = {}
		table.sort(coreData.disciplines)
		for _, val in pairs(coreData.disciplines) do
			table.insert(capabilies, val)
		end
	end
	if coreData.discipline_nekromantie and #coreData.discipline_nekromantie > 0 then
		capabilies_data.Nekromantie = { paths = {} }
		for _, val in pairs(coreData.discipline_nekromantie) do
			table.insert(capabilies_data.Nekromantie.paths, val)
		end
		table.sort(capabilies_data.Nekromantie.paths)
	end
	if coreData.discipline_thaumaturgie and #coreData.discipline_thaumaturgie > 0 then
		capabilies_data.Thaumaturgie = { paths = {} }
		for _, val in pairs(coreData.discipline_thaumaturgie) do
			table.insert(capabilies_data.Thaumaturgie.paths, val)
		end
		table.sort(capabilies_data.Thaumaturgie.paths)
	end



	-- first, get all abilities in the system for plausibility purposes
	local abilities = {}
	local query = {
		select = { '[[Is member of class::DisciplineAbility]]' },
		fields = { 'has ability name', 'has level', 'costs vitae', 'costs willpower', 'needs roll on', 'targets', 'lasts for',  --'has short description',
			'has_instruction', 'is_associated_to_page=page', 'is_identified_by_classengine_through=id'}
	}
	local attributes = {
		sort = 'Is associated to page,Has_level,Has ability name',
		order = 'asc,asc,asc',
	}
	local result = ClassPerson.mySmwUtil.ask(query, attributes)
	if result and #result > 0 then
		for _, row in pairs(result) do
			abilities[row['has ability name']] = row
			abilities[row['has ability name']]['rank'] = row['has level']
		end
	end

	-- now get all disciplies in the system and check, whether they have values set
	local query = {
		select = { '[[Kategorie:Disziplinen]]' },
		fields = { 'is path of=path', }
	}
	local attributes = {
		sort = 'has display title',
		order = 'asc',
	}
	local result = ClassPerson.mySmwUtil.ask(query, attributes)


	-- and finally some bool adjusts
	coreData.antitribu = FoundationClass.myYesno(coreData.antitribu) and 'Ja' or 'Nein'
	coreData.coterie = FoundationClass.myYesno(coreData.coterie) and 'Ja' or 'Nein'
	coreData.died = FoundationClass.myYesno(coreData.died) and 'Ja' or 'Nein'
	coreData.embraced_is_estimate = FoundationClass.myYesno(coreData.embraced_is_estimate) and 'Ja' or 'Nein'
	return coreData	-- this is your new coreData.
end

function ClassPerson:myDataAdjustments(data)
	_debug(self, 1, 'entering ClassPerson:myDataAdjustments(data) to convert data from data store into data suitable for argument processing, from ' .. tostring(self))
	-- function that performs some individual transformation datastore data into argument data
	-- keep in mind, when using smw data store, that data is indexed by parameter names, not properties
	-- hint: for conversion bool values, this is useful: FoundationClass.myYesno
	local data = data
	data.coterie = FoundationClass.myYesno(data.coterie) and 'Ja' or 'Nein'
	data.died = FoundationClass.myYesno(data.died) and 'Ja' or 'Nein'
	return data	-- this is your new data table, being passed on to initFromArgs and subsequently to plausibility testing
end

function ClassPerson:myPlausibilityTest(args)
	_debug(self, 1, 'entering ClassPerson:myPlausibilityTest(args) to test arguments, from ' .. tostring(self))
	-- function that performs the individual plausibility tests
	-- note: before you access a field args.fieldname you should check for existance
	-- use self:addError(text); this also puts the page in its class's gardening category
	return false	-- return value will be ignored. but if you add any error, the object's initialization will fail with the error
end

function ClassPerson:myStashAdjustments(stash, storeType)
	_debug(self, 1, 'entering ClassPerson:myStashAdjustments(stash) to do some minor adjustments on data before storing, from ' .. tostring(self))
	-- function that alters the stash before storing the data. if necessary, you can complate skip storing this stash, if you return false or the empty table {}
	-- storeType is the actual method of storage for this call. either 'cargo', or 'smw'
	-- hint: for conversion bool values, this is useful: FoundationClass.myYesno
	local stash = stash
	stash.antitribu = FoundationClass.myYesno(stash.antitribu)
	stash.coterie = FoundationClass.myYesno(stash.coterie)
	stash.embraced_is_estimate = FoundationClass.myYesno(stash.embraced_is_estimate)
	stash.died = FoundationClass.myYesno(stash.died)
	return stash	-- this is your new stash. this will be stored. it has format (fieldname: value)
end

function ClassPerson:method()
	_debug(self, 1, 'entering ClassPerson:method() to do something, from ' .. tostring(self))
	return true
end

return ClassPerson