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