Module:FFSchema
Summary
Allows you to use JSON schemas to create forms.
Uses
local p = {}
local mFFInput = require('Module:FFInput')
--[[
Separate handler for base props (currently)
{{#invoke:FFSchema|class|id= |page= |class=
|slot= |fields= |template= }}
]]--
p.class = function(frame)
-- params:
local newPage = frame.args.page or nil
local class = frame.args.class or nil
if newPage == nil or class == nil then return "" end
--
local id = frame.args.id or "create-class-instance"
local slot = frame.args.slot or "ws-base-props"
-- currently one val only
local fieldStr = frame.args.fields or "Class"
local template = frame.args.template or "Base properties"
-- e.g. <_create id="wscreate-base" mwwrite="Titel/{{#tool:randomint|1000000|9999999}}" mwslot="ws-base-props" mwtemplate="Base properties" mwfields="Class" mwfollow="true" />
local createAttrbs = {
id = id,
mwwrite = newPage,
mwslot = slot,
mwtemplate = template,
mwfields = fieldStr,
mwfollow = "true"
}
local createTag = mw.text.tag( "_create", createAttrbs, false )
-- e.g. <_input type="hidden" name="Class" value="Titles" />
local classAttrbs = {
["type"] = "hidden",
name = fieldStr,
value = class
}
local classInput = mw.text.tag( "_input", classAttrbs, false )
return frame:preprocess( createTag .. classInput )
end
--[[
main entry point - @todo rename wiki
@frame table
- schema (olim json) - pagename of JSON schema
- page - title of existing page, or title of new page to be created
- slot
- template - wiki template if any. Without it, we're assuming the content is JSON (detect content model with WSSlots)? @todo: what if we are in interested in the raw content?
create
{{#invoke:FFSchema |wiki
|schema=Json:FFSchema23
|mode=create
|page=Titel/{{#tool:randomint|1000000|9999999}}
|slot=ws-page-props
|template=Text
|defaults=...
}}
edit
{{#invoke:FFSchema |wiki
|schema=Json:FFSchema23
|mode=edit
|page={{FULLPAGENAME}}
...etc
}}
mode (optional)
The schema should define a couple of possible 'modes', currently 'create' and 'edit'. They can be used to add the necessary _create or _edit elements. For each of these modes, the corresponding 'actions' are defined.
@todo Consider custom actions other than edit and create
Field definitions accept two types of parameters:
- those that are native to FlexForm
- additional parameters beginning with an underscore (_) that can assist in some tedious tasks, including _type, _label, _default,_fields _options, _optionsep, _fields, _instance, _note (before), _tooltip, _itemClass, _htmlElement and _content, and _filtertemplate
with select/token:
- with _options you can set 'arrays' of either single values or pairs of 'label' and 'value'
At the time of writing, FlexForm is not stable with regard to its JavaScript implementation of instances
]]--
p.wiki = function(frame)
-- 'wiki' = legacy name
return p.page(frame)
end
p.page = function(frame)
local schema = frame.args.schema or frame.args.json or ""
-- read-only!
-- @todo check that schema exists and is valid
local schemaTbl = mw.loadJsonData( schema )
if schemaTbl == nil then return "" end
local mode = frame.args.mode or "fields"
local page = frame.args.page or ""
local slot = frame.args.slot or "main"
local template = frame.args.template or nil
local sourceFormat = "json"
if ( template ~= nil and template ~= "" ) then
sourceFormat = "wiki"
end
-- default values in the format name=value ### name=value ### etc.
-- allows for custom delimiter/sep
local defaults = frame.args.defaults or ""
local defaultsSep = frame.args.defaultssep or "###"
-- get content from page/slot for autofill
local slotContent = nil
if mode == "create" then
-- for now attempt nothing - page does not exist
elseif page ~= "" or page ~= nil then
if sourceFormat == "wiki" then
slotContent = p.getSlotContent( page, slot, template )
else
slotContent = p.getSlotContent( page, slot, nil )
end
end
local prefillTbl = p.createPrefillTable( sourceFormat, slotContent, defaults, defaultsSep )
-- fields = form field definitions
local fieldDefinitions = schemaTbl.fields or nil
if fieldDefinitions == nil then return "" end
-- edit/create actions or ""
local actionTags = p.setupActionTags( page, mode, schemaTbl, fieldDefinitions )
-- fields
local fieldStr = p.buildFromFieldDefinitions( fieldDefinitions, sourceFormat, prefillTbl, false )
-- mw.log( "FlexForm result: " .. mw.text.unstrip( str ) )--
return frame:preprocess( actionTags .. fieldStr )
end
--[[
@fieldDefinitions table
@sourceFormat string
@prefillTbl table
@isNested bool
]]--
p.buildFromFieldDefinitions = function( fieldDefinitions, sourceFormat, prefillTbl, isNested )
--frame = mw.getCurrentFrame()
--str = ""
local res = {}
local fieldDefinitions = fieldDefinitions or {}
for _,def in ipairs(fieldDefinitions) do
local f
if def["_type"] == "fieldset" and def["_fields"] ~= nil then
-- ! needs to be tested -- inputType = def["_type"] or nil
-- @todo allow other custom definitions
f = p.createPopulatedFieldset(
def,
p.buildFromFieldDefinitions( def["_fields"], sourceFormat, prefillTbl, true )
)
-- str = str .. fieldset
--table.insert(res, fieldset)
else
f = p.buildFromFieldDefinition( def, sourceFormat, prefillTbl )
end
table.insert(res, f )
end
return table.concat(res,"")
--return str
end
--[[
@def table
@sourceFormat string
@prefillTbl
]]--
p.buildFromFieldDefinition = function( def, sourceFormat, prefillTbl )
if def.name ~= nil then
nameWithoutBrackets = string.gsub( def.name, "%[%]", "" )
else
nameWithoutBrackets = ""
end
local val = nil
if nameWithoutBrackets == "" then
--do nothing
elseif prefillTbl ~= nil then
val = prefillTbl[nameWithoutBrackets] or nil
if val == "" or val == nil then val = def["_default"] or nil end
else
val = def["_default"] or nil
end
--[[
if sourceFormat == "wiki" then
-- todo could more efficient
--mw.log( "wiki content " )
if ( slotContent ~= nil and slotContent[1] ~= nil and slotContent[1][nameWithoutBrackets] ~= nil ) then
--[param]["_text"]
val = slotContent[1][nameWithoutBrackets]["_text"] or nil
if val == "" or val == nil then
val = def["_default"] or nil end
else
val = def["_default"] or nil
end
elseif sourceFormat == "json" and slotContent ~= nil then
--mw.log( "JSON content " )
--mw.log( "type: " .. type(slotContent[nameWithoutBrackets]) .. "<br>" )
--val may be string, table or nil
--mw.log( slotContent[nameWithoutBrackets] )
val = slotContent[nameWithoutBrackets] or nil
if val == "" or val == nil then
val = def["_default"] or nil
end
else
mw.log( "No content detected " )
end
if type(val) ~= "table" then
mw.log( "val: " .. ( val or "(none)" ) )
end
]]--
return p.parseFieldDefinition( def, val )
end
--[[
@def
@selectedVal string, table (JSON instance only) or nil
@boolean
]]--
p.parseFieldDefinition = function( def, selectedVal )
--name = def.name or ""
local nameWithoutBrackets = string.gsub( def.name or "", "%[%]", "" )
local inputType = def["_type"] or nil
selectedVal = selectedVal or nil
-- optional pre-filter for selected values (string only)
if attributes["_filtertemplate"] ~= nil and selectedVal ~= nil then
local currentFrame = mw.getCurrentFrame()
selectedVal = frame:expandTemplate{
title = attributes["_filtertemplate"],
args = { selectedVal }
}
end
-- @todo revise 'for'
local labelText = def['_label'] or ""
if def["required"] ~= nil and def["required"] == "required" then
-- @todo localisation, make choice configurable, not dependent on Bootstrap
labelText = labelText .. ' <sup class="fa fa-asterisk text-danger" title="verplicht"></sup>'
end
local labelTag = mw.text.tag( "label", { ["for"] = nameWithoutBrackets }, labelText )
--mw.log( "label: " .. labelTag .. " ... " )
local tooltipText = def['_tooltip'] or nil
local itemClass = def["_itemClass"] or "ff-item"
if def["_type"] == "instance" then
itemClass = itemClass .. " ff-item-instances"
end
local itemShowOnSelectTrigger = def["_show-on-select-trigger"] or def["_data-wssos-value"] or nil
-- note before input
local beforeInputField = ""
local note = def['_note'] or nil
if note ~= nil and note ~= "" then
local currentFrame = mw.getCurrentFrame()
beforeInputField = "<div class='ff-note'>" .. currentFrame:preprocess(note) .. "</div>"
end
-- whether to ignore item layout:
local standalone = false
local attributes = {}
for k,v in pairs( def ) do
attributes[k] = v or ""
end
local inputField = ""
if inputType == "instance" or inputType == "instances" then
local instanceLabelTag = labelTag
if attributes.template ~= nil then
-- wiki template version
if selectedVal ~= nil then
attributes["default-content"] = mw.text.nowiki( selectedVal )
end
inputField = p.createTemplateInstance( attributes )
else
-- JSON version
selectedVal = selectedVal or nil
if type(selectedVal) == "table" then
attributes["default-content"] = mw.text.nowiki( mw.text.jsonEncode( selectedVal ) )
elseif type(selectedVal) == "string" then
-- shouldn't happen but..
attributes["default-content"] = mw.text.nowiki( selectedVal )
end
inputField = p.createJsonInstance( attributes )
end
-- todo
-- attributes.fields
--??
labelTag = instanceLabelTag
elseif inputType == "text" then
-- @todo default class
if ( attributes.class == nil ) then
attributes.class = "form-control"
end
selectedVal = selectedVal or nil
inputField = mFFInput.createTextInput( nameWithoutBrackets, attributes, selectedVal )
elseif inputType == "number" then
-- @todo default class
if ( attributes.class == nil ) then
attributes.class = "form-control"
end
selectedVal = selectedVal or nil
inputField = mFFInput.createNumberInput( nameWithoutBrackets, attributes, selectedVal )
elseif inputType == "date" then
if ( attributes.class == nil ) then
attributes.class = "form-control"
end
selectedVal = selectedVal or nil
local attributes = p.removeNonFFAttributes( attributes )
inputField = mFFInput.createDateInput( nameWithoutBrackets, attributes, selectedVal )
elseif inputType == "hidden" then
--todo - temporary solutipn
itemClass = "d-none"
selectedVal = selectedVal or nil
inputField = mFFInput.createTextInput( nameWithoutBrackets, attributes, selectedVal )
elseif inputType == "textarea" then
-- @todo default class
if attributes.class == nil then
attributes.class = "form-control"
end
local attributes = p.removeNonFFAttributes( attributes )
local selectedVal = selectedVal or ""
inputField = mFFInput.createTextarea( nameWithoutBrackets, attributes, selectedVal)
elseif ( inputType == "token" or inputType == "tokens" ) then
-- @todo just an example
-- @todo remove stuff from attributes that does not belong
-- run attributes through a validator
local options = {}
if ( attributes['_options'] ~= nil and attributes['_options'] ~= "" ) then
options = attributes['_options']
if type(options) == "string" then
-- expand wikitext
local currentFrame = mw.getCurrentFrame()
local optionText = currentFrame:preprocess( options )
-- @todo what's a good for default for _optionsep (semi-colon?)
local optionSep = attributes['_optionsep'] or "\n"
options = mw.text.split( optionText, optionSep )
end
end
local attributes = p.removeNonFFAttributes( attributes )
local selectedVal = selectedVal or nil
inputField = mFFInput.createTokenField( nameWithoutBrackets, attributes, selectedVal, options )
--mw.log( "FlexForm token: " .. inputField )
elseif inputType == "select" then
if ( attributes['_options'] ~= nil and attributes['_options'] ~= "" ) then
options = attributes['_options']
end
local attributes = p.removeNonFFAttributes( attributes )
local selectedVal = selectedVal or nil
--mw.log( selectedVal or "select : selectedVal: none!" )
inputField = mFFInput.createSelectField( nameWithoutBrackets, attributes, selectedVal, options )
--mw.log( "FlexForm select: " .. inputField )
elseif inputType == "checkboxes" or inputType == "checkbox" then
if ( attributes["_options"] ~= nil and attributes["_options"] ~= "" ) then
options = attributes["_options"]
end
local attributes = p.removeNonFFAttributes( attributes )
local selectedVal = selectedVal or nil
inputField = mFFInput.createCheckInputField( "checkbox", nameWithoutBrackets, attributes, selectedVal, options )
elseif inputType == "radio" then
if ( attributes["_options"] ~= nil and attributes["_options"] ~= "" ) then
options = attributes["_options"]
end
local attributes = p.removeNonFFAttributes( attributes )
local selectedVal = selectedVal or nil
inputField = mFFInput.createCheckInputField( "radio", nameWithoutBrackets, attributes, selectedVal, options )
elseif inputType == "rating" then
local steps = nil
if attributes["_options"] ~= nil then
-- semi-colon separated list from 0.5;
steps = attributes["_options"]
end
-- @todo make configurable - starLabel, starsLabel, isCancellable, cancelTitle, static
inputField = mFFInput.createRatingField( nameWithoutBrackets, selectedVal, steps, "ster", "sterren", "true", "Annuleren" )
elseif attributes["_htmlElement"] ~= nil then
-- method closest to FlexForm's JSON schema
local el = attributes["_htmlElement"]
local content = attributes["_content"] or ""
local sosTrigger = attributes["show-on-select-trigger"] or attributes["data-wssos-value"] or nil
if sosTrigger ~= nil then
-- because Lua somehow throws away this attribute
attributes["data-wssos-value"] = sosTrigger
end
local attributes = p.removeNonFFAttributes( attributes )
inputField = mw.text.tag( el, attributes, content )
--[[
inputFieldTbl = mw.html.create( el )
:attr( attributes )
:wikitext( content )
inputField = tostring(inputFieldTbl)
]]--
standalone = true
end
-- item
-- @todo id and show-on-select id on
if standalone then
local res = inputField
return res
else
local res = p.buildItemLayout( labelTag, tooltipText, inputField, beforeInputField, itemClass, itemShowOnSelectTrigger )
labelTag = nil
return res
end
end
--[[
@labelTag
@tooltipText string|nil
@inputField
@beforeInputField - optional short message to be inserted just before the input
@itemClass string
@itemShowOnSelectTrigger nil|string
]]--
p.buildItemLayout = function( labelTag, tooltipText, inputField, beforeInputField, itemClass, itemShowOnSelectTrigger )
local tooltip = ""
if tooltipText ~= nil then
-- smw tooltip
local frame = mw.getCurrentFrame()
-- @todo create tooltip which does not depend on SMW's info
tooltip = frame:callParserFunction( '#info', { tooltipText } )
end
local labelDiv = mw.html.create( "div" )
:attr( "class", "item-label" )
:wikitext( labelTag .. tooltip )
--labelItem = "<div class='item-label'>" .. labelTag .. "</div>"
local labelItem = tostring(labelDiv)
local fieldDiv = mw.html.create( "div" )
:attr( "class", "item-field" )
:wikitext( beforeInputField .. inputField )
local fieldItem = tostring(fieldDiv)
local resDiv = mw.html.create( "div" )
:attr( "class", itemClass )
:wikitext( labelItem .. fieldItem )
if itemShowOnSelectTrigger ~= nil then
-- show-on-select-trigger
resDiv:attr( "data-wssos-value", itemShowOnSelectTrigger )
end
return tostring(resDiv)
end
p.createTemplateInstance = function( attributes )
local itemStr = ""
--frame = mw.getCurrentFrame()
for _,def in ipairs( attributes['_fields'] or {} ) do
-- @todo defaults?
--val = def["_default"] or nil
--don't use 'val' arg because the instance takes care of this
itemStr = itemStr .. p.parseFieldDefinition( def, nil )
end
local attributes = p.removeNonFFAttributes( attributes )
--content = "<div class='item-instance'>" .. itemStr .. "</div>"
local contentDiv = mw.html.create("div")
:attr( "class", "item-instance" )
:wikitext( itemStr )
local content = tostring(contentDiv)
return mw.text.tag( "_instance", attributes, content )
end
-- Identical to createTemplateInstance, currently
p.createJsonInstance = function( attributes )
local itemStr = ""
--name="Items" format="json"
for _,def in ipairs( attributes['_fields'] or {} ) do
itemStr = itemStr .. p.parseFieldDefinition( def, nil )
end
local attributes = p.removeNonFFAttributes( attributes )
local contentDiv = mw.html.create("div")
:attr( "class", "item-instance" )
:wikitext( itemStr )
local content = tostring(contentDiv)
return mw.text.tag( "_instance", attributes, content )
end
--[[
@page string - full name of page
@slot - name of slot
@template - name of the template (without NS prefix)
@return table
]]--
p.getSlotContent = function( page, slot, template )
local template = template or nil
if ( template == "" or template == nil ) then
-- Assuming JSON
if slot == "main" then
--loadJsonData does not alway work. Use WSSlots instead
--return mw.loadJsonData( page )
end
local str = mw.slots.slotContent( slot, page )
if type(str) == "table" then
-- @todo VERY unlikely
return str
end
if str ~= nil then
return mw.text.jsonDecode( str )
else
return {}
end
end
-- template
local slotData = mw.slots.slotData( slot, page )
if ( slotData == nil ) then
return type(slotData)
end
return slotData[template]
end
p.showSlotContent = function( frame )
local page = frame.args.page
local slot = frame.args.slot or "main"
local template = frame.args.template or nil
local content = p.getSlotContent( page, slot, template )
local str = mw.text.jsonEncode( content )
return str
end
--[[
if ( content == nil ) then
str = mw.slots.slotContent( slot, page )
return "content seems to be nil . " .. st
end
return "<pre>" .. mw.text.jsonEncode( content ) .. "</pre>"
]]--
p.createPopulatedFieldset = function( def, fieldsetContent )
local def = def or {}
local fieldsetContent = fieldsetContent or ""
local fieldDefs = def["_fields"] or {}
local itemShowOnSelectTrigger = def["_show-on-select-trigger"] or def["_data-wssos-value"] or nil
if itemShowOnSelectTrigger ~= nil then def["data-wssos-value"] = itemShowOnSelectTrigger end
return mw.text.tag(
"fieldset",
p.removeNonFFAttributes( def ),
fieldsetContent or ""
)
end
p.setupActionTags = function( page, mode, schemaTbl, fieldDefinitions )
if mode ~= "create" and mode ~= "edit" then return "" end
-- modes define which action tag must be used
local modes = schemaTbl.modes or nil
local actions = schemaTbl.actions or nil
if modes == nil or actions == nil then return "" end
local actionIds = modes[mode] or nil
if actionIds == nil then return "" end
local actionTags = ""
for _,id in ipairs( actionIds ) do
local def = actions[id]
actionTags = actionTags .. p.createActionTag( page, def, fieldDefinitions )
end
return actionTags
--[[ older approach
if mode == "new" then
local actionDefs = schemaTbl.new or {}
for _,def in ipairs(actionDefs) do
actionTags = actionTags .. p.createActionTag( page, def, fieldDefinitions )
end
end
]]--
end
--[[
work in progress
@page string
@attrs table (read-only, assoc)
@fieldDefs table (read-only)
]]--
p.createActionTag = function( page, attributes, fieldDefs )
-- create proxy for read-only attributes
local attrbs = {}
for k,v in pairs( attributes ) do attrbs[k] = v end
if attrbs["mwwrite"] == nil then
attrbs["mwwrite"] = page
end
if attrbs["mwfields"] == nil then
local fieldsTbl = p.getFieldNames( fieldDefs )
if attrbs["_excludeFields"] ~= nil then
-- when using multiple _creates you may want to exclude specific fields
local invalidFields = mw.text.split( attrbs["_excludeFields"], "," )
fieldsTbl = p.removeValuesFromSequentialTable( fieldsTbl, invalidFields )
end
attrbs["mwfields"] = table.concat( fieldsTbl, "," )
end
-- default tag is _create
local tag = "_create"
if attrbs["_type"] ~= nil then
tag = attrbs["_type"]
end
local attrbs = p.removeNonFFAttributes(attrbs)
return mw.text.tag( tag, attrbs, false )
end
--[[
Get the field names (as a table) so that they can be added to 'mwfields'
@fields table|nil
@return table
]]--
p.getFieldNames = function( fields )
if fields == nil then return {} end
local fieldNames = {}
for _,field in ipairs(fields) do
if field.name ~= nil then
-- remove [] if any
local fieldName = string.gsub( mw.text.trim(field.name), "%[%]", "" )
table.insert(fieldNames, fieldName)
end
end
return fieldNames
end
--[[
Remove parameters that are not FlexForm attributes
i.e. removes each parameter whose key begins with an underscore
]]--
p.removeNonFFAttributes = function( attributes )
local newAttributes = {}
for k,v in pairs(attributes) do
if ( string.sub( k, 1, 1 ) ~= "_" ) then
newAttributes[k] = v
end
end
return newAttributes
end
p.removeValuesFromSequentialTable = function( tbl, invalidFields )
for _,nonValid in ipairs(invalidFields) do
for i,v in ipairs(tbl) do
if v == nonValid then
table.remove( tbl, i )
end
end
end
return tbl
end
p.printAssocTable = function( tbl )
local str = ""
for k,v in pairs(tbl) do
str = str .. k .. " = " .. v .. ". "
end
return str
end
--[[
Create standardised prefill table as k/v pairs
from either pre-existing content (JSON, wikitext) when editing
or defaults when creating a page
@defaults
]]--
p.createPrefillTable = function( sourceFormat, slotContent, defaultStr, defaultsSep )
local slotContent = slotContent or nil
local defaults = defaults or nil
local prefillTbl = {}
if slotContent ~= nil and sourceFormat == "json" then
prefillTbl = slotContent
elseif slotContent ~= nil and slotContent[1] ~= nil and sourceFormat == "wiki" then
-- note ["_text"]
for k,v in pairs( slotContent[1] ) do
prefillTbl[k] = v["_text"] or nil
end
elseif defaultStr ~= nil then
-- new page
local defaults = mw.text.split( defaultStr, defaultsSep )
for _,v in ipairs( defaults ) do
local pair = mw.text.split( v, "=" )
if pair[2] ~= nil then
prefillTbl[ mw.text.trim( pair[1] ) ] = mw.text.trim( pair[2] )
end
end
end
return prefillTbl
end
return p