Module:Release

local p = {} local h = {}

local Franchise = require("Module:Franchise") local utilsArg = require("Module:UtilsArg") local utilsCargo = require("Module:UtilsCargo") local utilsMarkup = require("Module:UtilsMarkup") local utilsRegion = require("Module:UtilsRegion") local utilsString = require("Module:UtilsString") local utilsTable = require("Module:UtilsTable")

local data = mw.loadData("Module:Releases/Data")

local TABLES = { Games = "GameReleases" } local FIELDS = { Games = { title = "String", system = "String", service = "String", program = "String", region = "String", date = "Date", reference = "Wikitext", } }

function p.CargoDeclare(frame) local medium = frame.args[1] return utilsCargo.declare(TABLES[medium], FIELDS[medium]) end

function p.CargoStore(frame) local medium = frame.args[1] local args, err = utilsArg.parse(frame:getParent.args, p.Templates["Game Releases/Store"]) if err then return utilsMarkup.categories(err.categories) end local rows = {} for _, region in ipairs(data.regions) do		if args[region.param] then local row = utilsTable.merge({}, args, {				region = region.code,				date = args[region.param],				reference = args[region.param .. "R"],			}) utilsCargo.store(TABLES[medium], row) table.insert(rows, row) end end return h.printReleases(medium, rows) end

function p.Releases(frame) return p.printReleases(frame.args[1], frame:getParent.args[1]) end

function p.printReleases(medium, title) local releases = h.fetchReleases(medium, title) local result = h.printReleases(medium, releases) return result end

function h.fetchReleases(medium, title) local tbl = TABLES[medium] local fields = utilsTable.keys(FIELDS[medium]) local query = { where = utilsCargo.allOf({ title = title }) }	local queryResults = utilsCargo.query(tbl, table.concat(fields, ","), query) return queryResults end

function h.evaluateReleases(medium, releases) local releasesByName = utilsTable.groupBy(releases, h.labelers[medium]) local sortedReleasesByName = {} for k, v in pairs(releasesByName) do		local sortedIndex = h.sorters[medium](v[1]) sortedReleasesByName[sortedIndex] = { name = k,			regionDates = v		} end return utilsTable.compact(sortedReleasesByName) end

function h.printReleases(medium, releases) releases = h.evaluateReleases(medium, releases) for i, release in ipairs(releases) do		local dates = {} local regionDates = utilsTable.keyBy(release.regionDates, "region") for _, region in ipairs(data.regions) do			local regionCode = data.regionsByParam[region.param].code local regionDate = regionDates[regionCode] if regionDate then local formattedDate = mw.language.getContentLanguage:formatDate("M d, Y", regionDate.date) local date = utilsRegion.flag(regionCode) .. " " .. formattedDate if not utilsString.isEmpty(regionDate.reference) then date = date .. mw.getCurrentFrame:extensionTag("ref", regionDate.reference) end table.insert(dates, date) end end releases[i] = utilsTable.concat({release.name}, dates) end return utilsMarkup.definitionList(releases, {		class = "releases"	}) end

-- GAMES

function h.labelGameRelease(release) local label if not utilsString.isEmpty(release.service) then label = data.Games.services[release.system][release.service].displayName else label = data.Games.systemsByCode[release.system].name end if not utilsString.isEmpty(release.program) then label = label .. (" (%s)"):format(data.Games.programs[release.system][release.program]) end return label end

function h.sortGameRelease(release) return utilsTable.keyOf(data.Games.systemCodes, release.system) end

h.labelers = { Games = h.labelGameRelease, } h.sorters = { Games = h.sortGameRelease, }

local regionParams = {} local regionParamsOrder = {} for _, region in ipairs(data.regions) do	regionParams[region.param] = { type = "string", desc = "Release date in " .. utilsRegion.region(region.code), trim = true, }	regionParams[region.param .. "R"] = { type = "string", desc = "Source reference for release date.", inline = true, trim = true, }	table.insert(regionParamsOrder, region.param) table.insert(regionParamsOrder, region.param .. "R") end

p.Templates = { ["Game Releases/Store"] = { wip = true, purpose = "Store information about game releases.", storesData = "Data:Releases/Games", format = "block", paramOrder = utilsTable.concat({1, 2, 3, 4}, regionParamsOrder), params = { [1] = {				name = "game", type = "string", required = true, enum = Franchise.enum, desc = "Game identifier.", inline = true, trim = true, },			[2] = {				name = "system", type = "string", required = true, enum = data.Games.systemCodes, desc = "Console or handheld that the game was released for.", inline = true, trim = true, },			[3] = {				name = "service", type = "string", enumDependsOn = "system", enum = function(system) return utilsTable.keys(data.Games.services[system] or {}) end, desc = "Software through which this game release is offered (e.g. Virtual Console).", inline = true, canOmit = true, trim = true, },			[4] = {				name = "program", type = "string", enumDependsOn = "system", enum = function(system) return utilsTable.keys(data.Games.programs[system] or {}) end, desc = "Loyalty program through which this release is offered (e.g. Nintendo 3DS Ambassador Program).", inline = true, canOmit = true, trim = true, }		}	} }

utilsTable.merge(p.Templates["Game Releases/Store"].params, regionParams)

return p