def setbotrunnernotsupportsthisai(botrunnername, ainame, aiversion):
botrunner = botrunnerhelper.getBotRunner( botrunnername )
for ai in botrunner.supportedais:
if ai.ai_base.ai_base_name == ainame and ai.ai_version == aiversion:
botrunner.supportedais.remove( ai )
Session.commit()
return (True,'')
def storeresult( botrunnername, matchrequest_id, result ):
# delete any existing result, saves doing check first...
matchrequest = getmatchrequest( matchrequest_id )
if matchrequest == None:
return
matchrequest.matchresult = MatchResult( result )
Session.commit()
def setbotrunnersupportsthismap(botrunnername, mapname):
# Now, register the map as supported map
botrunner = botrunnerhelper.getBotRunner(botrunnername)
for map in botrunner.supportedmaps:
if map.map_name == mapname:
return (True, "")
map = getMap(mapname)
botrunner.supportedmaps.append(map)
Session.commit()
return (True, "")
def add(self):
botrunnerName = self.form_result["botrunnerName"]
sharedSecret = self.form_result["sharedSecret"]
botrunner = BotRunner(botrunnerName, sharedSecret)
Session.add(botrunner)
Session.commit()
c.message = "Added ok"
return render('genericmessage.html')
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 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 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 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 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.modadmin):
c.message = "You must be logged in as a modadmin, temporary!"
return render('genericmessage.html')
engine = Session.query(Engine).filter(Engine.engine_id == id).first()
if engine == None:
c.message = "No such engine"
return render('genericmessage.html')
Session.delete(engine)
Session.commit()
c.message = "Deleted ok"
return render('genericmessage.html')
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")
def remove(self, id):
if not roles.isInRole(roles.mapadmin):
c.message = "You must be logged in as a mapadmin"
return render('genericmessage.html')
map = Session.query(Map).filter(Map.map_id == id).first()
if map == None:
c.message = "No such map"
return render('genericmessage.html')
Session.delete(map)
Session.commit()
c.message = "Deleted ok"
return render('genericmessage.html')
def remove(self, id):
if not roles.isInRole(roles.modadmin):
c.message = "You must be logged in as a modadmin"
return render("genericmessage.html")
mod = Session.query(Mod).filter(Mod.mod_id == id).first()
if mod == None:
c.message = "No such mod"
return render("genericmessage.html")
Session.delete(mod)
Session.commit()
c.message = "Deleted ok"
return render("genericmessage.html")
def list(self):
maps = Session.query(Map)
showForm = roles.isInRole(roles.mapadmin)
c.showForm = showForm
c.maps = maps
return render('viewmaps.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 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):
ais = Session.query(AI)
showForm = roles.isInRole(roles.aiadmin)
c.ais = ais
c.showForm = showForm
return render("viewais.html")
def list(self):
engines = Session.query(Engine)
showForm = roles.isInRole(roles.modadmin)
c.showForm = showForm
c.engines = engines
return render('viewengines.html')
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 remove(self, id):
if not roles.isInRole(roles.leagueadmin):
c.message = "You must be logged in as a leagueadmin"
return render('genericmessage.html')
request = Session.query(MatchRequest).filter(MatchRequest.matchrequest_id == id).first()
if request == None:
c.message = "No such request"
return render('genericmessage.html')
Session.delete(request)
Session.commit()
c.message = "Deleted ok"
return render('genericmessage.html')
def add(self):
if not roles.isInRole(roles.modadmin):
c.message = "You must be logged in as a modadmin. Sorry, temporary"
return render('genericmessage.html')
enginename = self.form_result["engineName"]
enginearchivechecksum = self.form_result["engineArchiveChecksum"]
engineurl = self.form_result["engineUrl"]
engine = Engine(enginename)
engine.engine_url = engineurl
engine.engine_archivechecksum = enginearchivechecksum
Session.add(engine)
Session.commit()
c.message = "Added ok"
return render('genericmessage.html')
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 add(self):
if not roles.isInRole(roles.modadmin):
c.message = "You must be logged in as a modadmin"
return render("genericmessage.html")
modname = self.form_result["modName"]
modarchivechecksum = self.form_result["modArchiveChecksum"]
modurl = self.form_result["modUrl"]
mod = Mod(modname)
mod.mod_url = modurl
mod.mod_archivechecksum = modarchivechecksum
Session.add(mod)
Session.commit()
c.message = "Added ok"
return render("genericmessage.html")
def add(self):
if not roles.isInRole(roles.mapadmin):
c.message = "You must be logged in as a mapadmin"
return render('genericmessage.html')
mapname = self.form_result["mapName"]
maparchivechecksum = self.form_result["mapArchiveChecksum"]
mapurl = self.form_result["mapUrl"]
map = Map(mapname)
map.map_url = mapurl
map.map_archivechecksum = maparchivechecksum
Session.add(map)
Session.commit()
c.message = "Added ok"
return render('genericmessage.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 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 validatesharedsecret(lbotrunnername, sharedsecret):
global botrunnername
botrunner = getBotRunner(lbotrunnername)
if botrunner == None:
# Never seen this botrunner before, just add it
botrunner = BotRunner(lbotrunnername, sharedsecret)
Session.add(botrunner)
Session.commit()
# if this fails, return true anyway
return True
else:
if botrunner.botrunner_sharedsecret == sharedsecret:
botrunnername = lbotrunnername
return True
return False
def add(self):
if not roles.isInRole(roles.accountadmin):
c.message = "You must be logged in as a accountadmin"
return render('genericmessage.html')
username = self.form_result['username']
userfullname = self.form_result['userfullname']
email = self.form_result['email']
password = self.form_result['password']
account = Account(username, userfullname)
account.passwordinfo = PasswordInfo(password)
account.email = email
Session.add(account)
Session.commit()
c.message = "Added ok"
return render('genericmessage.html')
def add(self):
if not roles.isInRole(roles.aiadmin):
c.message = "You must be logged in as aiadmin"
return render("genericmessage.html")
aiName = self.form_result["aiName"]
aiVersion = self.form_result["aiVersion"]
downloadUrl = self.form_result["downloadUrl"]
needsCompiling = self.form_result["needsCompiling"]
ai = AI(aiName, aiVersion)
ai.ai_downloadurl = downloadUrl
ai.ai_needscompiling = needsCompiling
ai.owneraccount = accounthelper.getAccount(session["user"])
Session.add(ai)
Session.commit()
c.message = "Added ok"
return render("genericmessage.html")
