def addLeagueMatches(league, matchRequestQueue, matchResults):
ais = Session.query(AI).join(LeagueAI).filter(LeagueAI.league_id ==\
league.league_id).all()
map = Session.query(Map).filter(Map.map_id == league.map_id).first()
mod = Session.query(Mod).filter(Mod.mod_id == league.mod_id).first()
playAgainstSelf = league.play_against_self
if league.side_modes == "xvsy":
sides = [int(i) for i in league.sides.split("vs")]
else:
sides = [int(league.sides)]
matchRequests = []
for i, ai0 in enumerate(ais[:-1]):
for j, ai1 in enumerate(ais[i:]):
if not playAgainstSelf and ai0.ai_id == ai1.ai_id:
continue
first = Session.query(ModSide).filter(ModSide.mod_side_id == sides[0]).first()
if len(sides) == 2:
second = Session.query(ModSide).filter(ModSide.mod_side_id == sides[1]).first()
allSides = [(first, second), (second, first)]
else:
allSides = [(first, first)]
for firstSide, secondSide in allSides:
for k in xrange(league.matches_per_ai_pair):
matchRequest = MatchRequest(ai0, ai1, map, mod,\
league.speed, league.soft_timeout, league.hard_timeout,\
firstSide, secondSide, league.league_id)
matchRequests.append(matchRequest)
#save all matches to the database
Session.add_all(matchRequests)
Session.commit()
def applydefaults():
global defaults
for key_name in defaults.keys():
configrow = Session.query(Config).filter(Config.config_key == key_name).first()
if configrow == None:
setValue(key_name, defaults[key_name])
# purge extraneous values
for configrow in Session.query(Config):
if not defaults.has_key(configrow.config_key):
Session.delete(configrow)
Session.flush()
def view(self, id):
account = Session.query(Account).filter(
Account.account_id == id).first()
showform = roles.isInRole(roles.accountadmin)
potentialroles = [i[0] for i in Session.query(Role.role_name)]
for role in account.roles:
potentialroles.remove(role.role_name)
c.account = account
c.showForm = showform
return render('viewaccount.html')
def results(self):
c.requests = Session.query(MatchRequest).filter(
MatchRequest.matchresult != None)
try:
league_id = int(request.params['league'])
c.requests = c.requests.filter(MatchRequest.league_id == league_id)
except:
pass
page = 1
try:
page = int(request.params['page'])
except:
pass
c.requests = paginate.Page(
c.requests,
page=page,
items_per_page=20)
c.replayPaths = {}
c.infologPaths = {}
for req in c.requests:
replayPath = replaycontroller.getReplayPath(req.matchrequest_id)
if os.path.isfile(replayPath):
c.replayPaths[req] = replaycontroller.getReplayWebRelativePath(
req.matchrequest_id)
if os.path.isfile(
replaycontroller.getInfologPath(req.matchrequest_id)):
c.infologPaths[req] = replaycontroller.\
getInfologWebRelativePath(req.matchrequest_id)
return render('viewresults.html')
def list(self):
maps = Session.query(Map)
showForm = roles.isInRole(roles.mapadmin)
c.showForm = showForm
c.maps = maps
return render('viewmaps.html')
def addmapifdoesntexist(mapname, maparchivechecksum):
map = Session.query(Map).filter(Map.map_name == mapname).first()
if map == None:
try:
map = Map(mapname)
map.map_archivechecksum = maparchivechecksum
Session.add(map)
Session.commit()
except:
return (False, "error adding to db: " + str(sys.exc_value))
return (True, "")
if map.map_archivechecksum == None:
map.map_archivechecksum = maparchivechecksum
try:
Session.commit()
return (True, "")
except:
return (False, "error updating db: " + str(sys.exc_value))
if map.map_archivechecksum != maparchivechecksum:
return (False, "map archive checksum doesn't match the one already on the website.")
return (True, "")
def getcompatibleitemfromqueue(botrunnername, sessionid):
archiveoldrequests()
botrunner = botrunnerhelper.getBotRunner( botrunnername )
botrunnersession = botrunnerhelper.getBotRunnerSession( botrunnername, sessionid )
# now we've archived the old requests, we just pick a request
# in the future, we'll pick a compatible request. In the future ;-)
# also, we need to handle options. In the future ;-)
matchrequests = Session.query(MatchRequest).filter(MatchRequest.matchrequestinprogress == None).filter(MatchRequest.matchresult == None).all()
for matchrequest in matchrequests:
mapok = False
modok = False
ai0ok = False
ai1ok = False
for map in botrunner.supportedmaps:
if map.map_name == matchrequest.map.map_name:
mapok = True
for mod in botrunner.supportedmods:
if mod.mod_name == matchrequest.mod.mod_name:
modok = True
for ai in botrunner.supportedais:
if ai.ai_base.ai_base_name == matchrequest.ai0.ai_base.ai_base_name and ai.ai_version == matchrequest.ai0.ai_version:
ai0ok = True
if ai.ai_base.ai_base_name == matchrequest.ai1.ai_base.ai_base_name and ai.ai_version == matchrequest.ai1.ai_version:
ai1ok = True
if mapok and modok and ai0ok and ai1ok:
# mark request in progress:
matchrequest.matchrequestinprogress = MatchRequestInProgress(botrunner, botrunnersession, datetime.datetime.now())
return matchrequest
# didn't find any compatible match
return None
def list(self):
engines = Session.query(Engine)
showForm = roles.isInRole(roles.modadmin)
c.showForm = showForm
c.engines = engines
return render('viewengines.html')
def list(self):
mods = Session.query(Mod)
showForm = roles.isInRole(roles.modadmin)
c.showForm = showForm
c.mods = mods
return render("viewmods.html")
def requests(self):
c.requests = Session.query(MatchRequest).filter(
MatchRequest.matchresult == None)
try:
league_id = int(request.params['league'])
c.requests = c.requests.filter(MatchRequest.league_id == league_id)
except:
pass
page = 1
try:
page = int(request.params['page'])
except:
pass
c.requests = paginate.Page(
c.requests,
page=page,
items_per_page=20)
c.datetimeassignedbyrequest = {}
for req in c.requests:
if req.matchrequestinprogress != None:
c.datetimeassignedbyrequest[req] = \
req.matchrequestinprogress.datetimeassigned
return render('viewrequests.html')
def remove(self, id):
if not roles.isInRole(roles.leagueadmin):
c.message = "You must be logged in as a leagueadmin"
return render('genericmessage.html')
league = Session.query(League).filter(League.league_id == id).first()
if league == None:
c.message = "No such league"
return render('genericmessage.html')
Session.query(LeagueAI).filter(LeagueAI.league_id == id).delete()
Session.delete(league)
Session.commit()
c.message = "Deleted ok"
return render('genericmessage.html')
def list(self):
ais = Session.query(AI)
showForm = roles.isInRole(roles.aiadmin)
c.ais = ais
c.showForm = showForm
return render("viewais.html")
def validateUsernamePassword(username, password):
account = Session.query(Account).filter(Account.username == username).first()
if account == None:
return False
if account.passwordinfo == None:
return False
result = account.passwordinfo.checkPassword(password)
return result
def purgeExpiredSessions():
botrunners = Session.query(BotRunner)
for botrunner in botrunners:
for session in botrunner.sessions:
if session.lastpingtime != None:
secondssincelastping = dates.timedifftototalseconds(datetime.datetime.now() - session.lastpingtime)
if secondssincelastping > confighelper.getValue("expiresessionminutes") * 60:
expireBotRunnerSession(botrunner, session)
def getValue(key_name):
global defaults
if not defaults.has_key(key_name):
raise Exception("confighelper.setvalue, no such key_name: " + key_name)
configrow = Session.query(Config).filter(Config.config_key == key_name).first()
if configrow == None:
return populatedefault(key_name)
return configrow.getValue()
def list(self):
#if loginhelper.gusername == '':
# jinjahelper.message( "Please login first before using this page.")
# return
c.accounts = Session.query(Account)
c.roles = roles
showform = roles.isInRole(roles.accountadmin)
return render('viewaccounts.html')
def isInRole2(username, rolename):
if rolename == None:
print "ERROR: no rolename specified"
return False
if rolename == '':
print "ERROR: no rolename specified"
return False
# validate rolename:
addstaticdata()
rolerow = Session.query(Role).filter(Role.role_name == rolename ).first()
if rolerow == None:
print "ERROR: invalid rolename specified"
return False
account = Session.query(Account).\
filter(Account.username == username ).\
filter( Account.roles.any( role_name = rolename )).first()
return ( account != None )
def view(self, id):
engine = Session.query(Engine).filter(Engine.engine_id == id).first()
if engine == None:
c.message = "No such engine"
return render('genericmessage.html')
showForm = roles.isInRole(roles.modadmin)
c.showForm = showForm
c.engine = engine
return render('viewengine.html')
def view(self, id):
mod = Session.query(Mod).filter(Mod.mod_id == id).first()
if mod == None:
c.message = "No such mod"
return render("genericmessage.html")
showForm = roles.isInRole(roles.modadmin)
c.showForm = showForm
c.mod = mod
return render("viewmod.html")
def view(self, id):
ai = Session.query(AIBase).filter(AIBase.ai_base_id == id).first()
if ai == None:
c.message = "No such ai"
return render("genericmessage.html")
showform = roles.isInRole(roles.aiadmin)
c.ai = ai
c.showForm = showform
return render("viewai.html")
def view(self, id):
botrunner = Session.query(BotRunner).filter(
BotRunner.botrunner_id == id).first()
c.isbotrunnerowner = ('user' in session and
botrunner.owneraccount != None and
botrunner.owneraccount.username == session['user'])
c.showform = (c.isbotrunnerowner or
roles.isInRole(roles.botrunneradmin))
c.botrunner = botrunner
return render('viewbotrunner.html')
def addstaticdata():
rolerows = Session.query(Role).all()
for rolename in [ 'accountadmin', 'aiadmin', 'mapadmin', 'modadmin', 'leagueadmin', 'botrunneradmin', 'requestadmin', 'apiclient' ]:
rolefound = False
for rolerow in rolerows:
if rolerow.role_name == rolename:
rolefound = True
if not rolefound:
role = Role(rolename)
Session.add(role)
Session.flush()
def view(self, id):
map = Session.query(Map).filter(Map.map_id == id).first()
if map == None:
c.message = "No such map"
return render('genericmessage.html')
showform = roles.isInRole(roles.mapadmin)
c.map = map
c.showForm = showform
return render('viewmap.html')
def populatedefault(key_name):
global defaults
configrow = Session.query(Config).filter(Config.config_key == key_name).first()
if configrow != None:
return configrow.getValue()
if not defaults.has_key(key_name):
return None
newvalue = defaults[key_name]
setValue(key_name, newvalue)
return newvalue
def setValue(key_name, key_value):
global defaults
if not defaults.has_key(key_name):
raise Exception("confighelper.setvalue, no such key_name: " + key_name)
configrow = Session.query(Config).filter(Config.config_key == key_name).first()
if configrow == None:
config = Config(key_name, key_value)
Session.add(config)
else:
configrow.setValue(key_value)
def list(self):
leagues = Session.query(League)
showForm = roles.isInRole(roles.leagueadmin)
mods = Session.query(Mod)
ais = Session.query(AI)
tmpais = {}
maps = Session.query(Map)
c.maps = {}
for map in maps:
c.maps[map.map_id] = map.map_name
mods = Session.query(Mod)
c.mods = {}
for mod in mods:
c.mods[mod.mod_id] = mod.mod_name
modsides = {}
for i, mod in enumerate(mods):
sides = Session.query(ModSide).filter(ModSide.mod_id == mod.mod_id)
modsides[mod.mod_name] = (i, [])
for side in sides:
modsides[mod.mod_name][1].append((side.mod_side_name, side.mod_side_id))
for ai in ais:
tmpais[ai.ai_id] = ai.ai_base.ai_base_name + " " + ai.ai_version
c.ais = tmpais
c.sides = modsides
c.showForm = showForm
c.leagues = leagues
c.sidemodes = { "allsame" : "All same", "xvsy" : "X vs Y" }
c.speeds = [20] #default
c.speeds.extend(range(1, 10))
c.speeds.extend(range(10, 101, 5))
c.timeouts = c.speeds
return render('viewleagues.html')
def form(self):
c.ais = Session.query(AIBase)
c.maps = [i[0] for i in Session.query(Map.map_name)]
c.mods = Session.query(Mod)
sidequery = Session.query(ModSide)
c.sides = {}
for i, mod in enumerate(c.mods):
c.sides[mod.mod_id] = (i, [])
for side in sidequery:
c.sides[side.mod_id][1].append((side.mod_side_name, side.mod_side_id))
c.mods = [mod.mod_name for mod in c.mods]
c.aiitems = []
c.aivalues = []
for ai in c.ais:
for ai_version in ai.versions:
c.aivalues.append(ai.ai_base_name + " " + ai_version.ai_version)
c.aiitems.append(ai_version.ai_id)
c.speeds = [i for i in range(1, 10)]
c.speeds.extend([i for i in range(10,101,5)])
c.timeouts = c.speeds
return render('submitrequestform.html')
def add(self):
if not roles.isInRole(roles.leagueadmin):
c.message = "You must be logged in as a leagueadmin"
return render('genericmessage.html')
leagueName = self.form_result["leagueName"]
modId = self.form_result["modId"]
mapId = self.form_result["mapId"]
speed = self.form_result["speed"]
softtimeout = self.form_result["softtimeout"]
hardtimeout = self.form_result["hardtimeout"]
nummatchesperaipair = self.form_result["nummatchesperaipair"]
sides = self.form_result["sides"]
sidemodes = self.form_result["sidemodes"]
playagainstself = self.form_result["playagainstself"]
account = Session.query(Account).filter(Account.username == session['user']).first()
ais = []
for i in range(Session.query(AI).count()):
ai_i = 'ai_checkbox_' + str(i)
if (self.form_result.has_key(ai_i)):
ais.append(i)
league = League(leagueName, account, modId, mapId,
nummatchesperaipair, speed, softtimeout, hardtimeout,
sides, sidemodes, playagainstself)
leagueais = [LeagueAI(ai, league) for ai in ais]
Session.add(league)
Session.add_all(leagueais)
matchrequests = Session.query(MatchRequest).filter(MatchRequest.league_id ==\
league.league_id)
matchresults = [req for req in matchrequests if req.matchresult != None]
matchscheduler.addLeagueMatches(league, matchrequests, matchresults)
Session.flush()
Session.commit()
redirect(url(controller='league', action='view', id=league.league_id))
def logonUserWithAuthenticatedOpenID(openidurl):
account = None
# note: this could be optimized a little...
for thisaccount in Session.query(Account):
for openid in thisaccount.openids:
if openid.openid == openidurl:
account = thisaccount
if account == None:
# create new account
account = Account(openidurl, openidurl)
account.openids.append(OpenID(openidurl))
Session.add(account)
session['username'] = openidurl
def remove(self, id):
if not roles.isInRole(roles.aiadmin):
c.message = "You must be logged in as a aiadmin"
return render("genericmessage.html")
ai = Session.query(AI).filter(AI.ai_id == id).first()
if ai == None:
c.message = "No such ai"
return render("genericmessage.html")
Session.delete(ai)
Session.commit()
c.message = "Deleted ok"
return render("genericmessage.html")
