def execute(self, request, user, x, y, z, fleets=False): week = Updates.week_tick() planet = Planet.load(x,y,z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) Q = session.query(FleetScan, Planet, Alliance) Q = Q.join(FleetScan.target) Q = Q.outerjoin(Planet.intel).outerjoin(Intel.alliance) Q = Q.filter(FleetScan.owner == planet) Q = Q.order_by(desc(FleetScan.landing_tick)) if not fleets: Q = Q.filter(FleetScan.landing_tick >= week) outgoing = Q.all() Q = session.query(FleetScan, Planet, Alliance) Q = Q.join(FleetScan.owner) Q = Q.outerjoin(Planet.intel).outerjoin(Intel.alliance) Q = Q.filter(FleetScan.target == planet) Q = Q.order_by(desc(FleetScan.landing_tick)) if not fleets: Q = Q.filter(FleetScan.landing_tick >= week) incoming = Q.all() scan = planet.scan("A") or planet.scan("U") return render("iplanet.tpl", request, planet=planet, scan=scan, outgoing=outgoing, incoming=incoming)
def execute(self, request, user): planet, galaxy = (user.planet, user.planet.galaxy,) if user.planet else (Planet(), Galaxy(),) planets = session.query(Planet).filter(Planet.active == True) galaxies = session.query(Galaxy).filter(Galaxy.active == True) alliances = session.query(Alliance).filter(Alliance.active == True) dup = lambda l,o,c=True: l+[o] if o in session and c and o not in l else l return render("index.tpl", request, topplanets = dup(planets.order_by(asc(Planet.score_rank))[:20], planet), roidingplanets = dup(planets.filter(Planet.size_growth > 0).order_by(desc(Planet.size_growth))[:5], planet, planet.size_growth > 0), roidedplanets = dup(planets.filter(Planet.size_growth < 0).order_by(asc(Planet.size_growth))[:5], planet, planet.size_growth < 0), xpplanets = dup(planets.filter(Planet.xp_growth > 0).order_by(desc(Planet.xp_growth))[:5], planet, planet.xp_growth > 0), bashedplanets = dup(planets.filter(Planet.value_growth < 0).order_by(asc(Planet.value_growth))[:5], planet, planet.value_growth < 0), topgalaxies = dup(galaxies.order_by(asc(Galaxy.score_rank))[:10], galaxy), roidinggalaxies = dup(galaxies.filter(Galaxy.size_growth > 0).order_by(desc(Galaxy.size_growth))[:5], galaxy, galaxy.size_growth > 0), roidedgalaxies = dup(galaxies.filter(Galaxy.size_growth < 0).order_by(asc(Galaxy.size_growth))[:5], galaxy, galaxy.size_growth < 0), xpgalaxies = dup(galaxies.filter(Galaxy.xp_growth > 0).order_by(desc(Galaxy.xp_growth))[:5], galaxy, galaxy.xp_growth > 0), bashedgalaxies = dup(galaxies.filter(Galaxy.value_growth < 0).order_by(asc(Galaxy.value_growth))[:5], galaxy, galaxy.value_growth < 0), topalliances = alliances.order_by(asc(Alliance.score_rank))[:8], )
def execute(self, request, user, message=None, planet=None): tick = Updates.current_tick() Q = session.query(Request) Q = Q.filter(Request.user == user) Q = Q.filter(Request.tick > tick - 5) Q = Q.filter(Request.active == True) Q = Q.order_by(asc(Request.id)) open = Q.all() Q = session.query(Scan) Q = Q.join(Request.scan) Q = Q.filter(Request.user == user) Q = Q.filter(Request.tick > tick - 24) Q = Q.filter(Request.scan != None) Q = Q.order_by(desc(Request.id)) completed = Q.all() Q = session.query(Scan) Q = Q.filter(Scan.scanner == user) Q = Q.order_by(desc(Scan.id)) scans = Q[:25] return render("scans/scans.tpl", request, anonscans=Config.getboolean("Misc", "anonscans"), types=Request._requestable, open=open, completed=completed, scans=scans, message=message, planet=planet)
def execute(self, message, user, params): tick = Updates.current_tick() + (params.group(1) or 1) replies = [] Q = session.query(Galaxy.x, Galaxy.y, count()) Q = Q.join(Target.planet) Q = Q.join(Planet.galaxy) Q = Q.filter(Planet.active == True) Q = Q.filter(Target.tick >= tick) Q = Q.group_by(Galaxy.x, Galaxy.y) result = Q.all() prev = [] for x, y, bitches in result: prev.append("%s:%s(%s)"%(x,y,bitches)) replies.append("Active bookings: " + ", ".join(prev)) Q = session.query(Alliance.name, count()) Q = Q.join(Target.planet) Q = Q.outerjoin(Planet.intel) Q = Q.outerjoin(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter(Target.tick >= tick) Q = Q.group_by(Alliance.name) result = Q.all() prev = [] for name, bitches in result: prev.append("%s (%s)"%(name or "Unknown", bitches)) replies.append("Active bitches: " + ", ".join(prev)) if len(replies) < 1: replies.append("No active bookings. This makes %s sad. Please don't make %s sad." %((Config.get("Connection","nick"),)*2)) message.reply("\n".join(replies))
def execute(self, request, user, sort=None): levels = [] + User.levels order = { "name": (asc(User.name), ), "sponsor": (asc(User.sponsor), ), "access": (desc(User.access), ), "planet": ( asc(Planet.x), asc(Planet.y), asc(Planet.z), ), } if sort not in order.keys(): sort = "name" order = order.get(sort) members = [] Q = session.query( User.name, User.alias, User.sponsor, User.access, Planet, User.phone, User.pubphone, User.id.in_( session.query(PhoneFriend.user_id).filter_by(friend=user))) Q = Q.outerjoin(User.planet) Q = Q.filter(User.active == True) Q = Q.filter(User.access < levels[-1][1]) for o in order: Q = Q.order_by(o) return render("galmates.tpl", request, members=Q.all())
def execute(self, request, user, sort=None): levels = [] + User.levels if sort is not None: levels = [("All member", levels[-1][1],),] order = {"name" : (asc(User.name),), "sponsor" : (asc(User.sponsor),), "access" : (desc(User.access),desc(User.carebears),asc(User.name),), "carebears" : (desc(User.carebears),), "planet" : (asc(Planet.x),asc(Planet.y),asc(Planet.z),), "defage" : (asc(User.fleetupdated),), } if sort not in order.keys(): sort = "name" order = order.get(sort) members = [] for level in levels: Q = session.query(User.name, User.alias, User.sponsor, User.access, User.carebears, Planet, User.fleetupdated, User.phone, User.pubphone, User.id.in_(session.query(PhoneFriend.user_id).filter_by(friend=user))) Q = Q.outerjoin(User.planet) Q = Q.filter(User.active == True) Q = Q.filter(User.access >= level[1]) Q = Q.filter(User.access < levels[levels.index(level)-1][1]) if levels.index(level) > 0 else Q for o in order: Q = Q.order_by(o) members.append((level[0], Q.all(),)) return render("members.tpl", request, accesslist=members, tick=Updates.current_tick()*-1)
def authenticate(self, request): request.session = None request.user = None key = request.COOKIES.get(SESSION_KEY) if key: auth = Arthur.load(key, datetime.now()) if auth is None: raise UserError("Your session has expired, please login again.") if request.path == LOGOUT: session.delete(auth) session.commit() raise UserError("Logged out.") request.session = auth return auth.user, None, key elif (request.POST.get(USER) and request.POST.get(PASS)): user = User.load(name=request.POST.get(USER), passwd=request.POST.get(PASS)) if user is None: raise UserError("Invalid user.") else: key = self.generate_key(user) auth = Arthur(key=key, expire=datetime.now()+timedelta(days=1), user=user) session.query(Arthur).filter(Arthur.user == user).delete() session.add(auth) session.commit() request.session = auth return user, key, key else: return None, None, None
def list(self, message, user, params): Q = session.query(func.count().label("count"), func.max(Request.id).label("max_id")) Q = Q.filter(Request.tick > Updates.current_tick() - 5) Q = Q.filter(Request.active == True) Q = Q.group_by(Request.planet_id, Request.scantype) Q = Q.order_by(asc("max_id")) SQ = Q.subquery() Q = session.query(Request, SQ.c.count).join((SQ, and_(Request.id == SQ.c.max_id))) if Q.count() < 1: message.reply("There are no open scan requests") return message.reply( " ".join( map( lambda (request, count): Config.get("Misc", "reqlist").decode("string_escape") % ( request.id, request.target.intel.dists if request.target.intel else "0", "/%s" % request.dists if request.dists > 0 else "", request.scantype, request.target.x, request.target.y, request.target.z, ), Q.all(), ) ) )
def execute(self, message, user, params): tick = Updates.current_tick() + int(params.group(1) or 1) replies = [] Q = session.query(Galaxy.x, Galaxy.y, count()) Q = Q.join(Target.planet) Q = Q.join(Planet.galaxy) Q = Q.filter(Planet.active == True) Q = Q.filter(Target.tick >= tick) Q = Q.group_by(Galaxy.x, Galaxy.y) result = Q.all() prev = [] for x, y, bitches in result: prev.append("%s:%s(%s)" % (x, y, bitches)) replies.append("Active bookings: " + ", ".join(prev)) Q = session.query(Alliance.name, count()) Q = Q.join(Target.planet) Q = Q.outerjoin(Planet.intel) Q = Q.outerjoin(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter(Target.tick >= tick) Q = Q.group_by(Alliance.name) result = Q.all() prev = [] for name, bitches in result: prev.append("%s (%s)" % (name or "Unknown", bitches)) replies.append("Active bitches: " + ", ".join(prev)) if len(replies) < 1: replies.append( "No active bookings. This makes %s sad. Please don't make %s sad." % ((Config.get("Connection", "nick"), ) * 2)) message.reply("\n".join(replies))
def list_fleets(self, message, user, params): # Check the planet exists planet = Planet.load(*params.group(1,3,5)) if planet is None: message.alert("No planet with coords %s:%s:%s" % params.group(1,3,5)) return # Find all fleets with a known alliance who have defended this planet OQ = session.query(coalesce(FleetScan.launch_tick, FleetScan.landing_tick), literal_column("'From'").label("dir"), Planet.x, Planet.y, Planet.z, Alliance.name).select_from(FleetScan) OQ = OQ.filter(FleetScan.target_id == planet.id, FleetScan.in_galaxy==False, FleetScan.mission=="Defend") OQ = OQ.join(Intel, FleetScan.owner_id == Intel.planet_id).filter(Intel.alliance_id != None) OQ = OQ.join(Alliance, Intel.alliance_id == Alliance.id).join(Planet, FleetScan.owner_id == Planet.id) # Find all fleets with a known alliance who have been defended by this planet TQ = session.query(coalesce(FleetScan.launch_tick, FleetScan.landing_tick), literal_column("'To '").label("dir"), Planet.x, Planet.y, Planet.z, Alliance.name).select_from(FleetScan) TQ = TQ.filter(FleetScan.owner_id == planet.id, FleetScan.in_galaxy==False, FleetScan.mission=="Defend") TQ = TQ.join(Intel, FleetScan.target_id == Intel.planet_id).filter(Intel.alliance_id != None) TQ = TQ.join(Alliance, Intel.alliance_id == Alliance.id).join(Planet, FleetScan.target_id == Planet.id) # Combine the results into one sorted list results = sorted(OQ.all()+TQ.all(), reverse=True) # Quit now if there are no results if len(results) == 0: message.reply("No suggestions found") return # Reply to the user message.reply("Tick Dir Planet Alliance") limit = int(params.group(6) or 5) for r in results[:limit]: message.reply("%4s %s %-9s %s" % (r[0], r[1], "%s:%s:%s" % (r[2], r[3], r[4]), r[5])) if len(results) > limit: message.reply("%s results not shown (%s total)" % (len(results)-limit, len(results)))
def authenticate(self, request): request.session = None request.user = None key = request.COOKIES.get(SESSION_KEY) if key: auth = Arthur.load(key, datetime.now()) if auth is None: raise UserError( "Your session has expired, please login again.") if request.path == LOGOUT: session.delete(auth) session.commit() raise UserError("Logged out.") request.session = auth return auth.user, None, key elif (request.REQUEST.get(USER) and request.REQUEST.get(PASS)): user = User.load(name=request.REQUEST.get(USER), passwd=request.REQUEST.get(PASS)) if user is None: raise UserError("Invalid user.") else: key = self.generate_key(user) auth = Arthur(key=key, expire=datetime.now() + timedelta(days=1), user=user) session.query(Arthur).filter(Arthur.user == user).delete() session.add(auth) session.commit() request.session = auth return user, key, key else: return None, None, None
def sum_votes(self, prop): yes = session.query(sum(Vote.carebears)).filter_by( prop_id=prop.id, vote="yes").scalar() no = session.query(sum(Vote.carebears)).filter_by(prop_id=prop.id, vote="no").scalar() veto = session.query(Vote).filter_by(prop_id=prop.id, vote="veto").count() return yes or 0, no or 0, veto or 0
def execute(self, request, user, sort=None): levels = [] + User.levels if sort is not None: levels = [ ( "All member", levels[-1][1], ), ] order = { "name": (asc(User.name), ), "sponsor": (asc(User.sponsor), ), "access": ( desc(User.access), desc(User.carebears), asc(User.name), ), "carebears": (desc(User.carebears), ), "planet": ( asc(Planet.x), asc(Planet.y), asc(Planet.z), ), "defage": (asc(User.fleetupdated), ), } if sort not in order.keys(): sort = "name" order = order.get(sort) members = [] for level in levels: Q = session.query( User.name, User.alias, User.sponsor, User.access, User.carebears, Planet, User.fleetupdated, User.phone, User.pubphone, or_( User.id == user.id, User.id.in_( session.query( PhoneFriend.user_id).filter_by(friend=user)))) Q = Q.outerjoin(User.planet) Q = Q.filter(User.active == True) Q = Q.filter(User.access >= level[1]) Q = Q.filter( User.access < levels[levels.index(level) - 1][1]) if levels.index(level) > 0 else Q for o in order: Q = Q.order_by(o) members.append(( level[0], Q.all(), )) return render("members.tpl", request, accesslist=members)
def execute(self, request, user, message=None): tick = Updates.current_tick() Q = session.query(Attack) if user.access < ( Config.getint("Access", "hc") if "hc" in Config.options("Access") else 1000 ): # Hide attacks until they are active, unless the user has access Q = Q.filter( Attack.landtick <= tick + Config.getint("Misc", "attactive")) Q = Q.filter( Attack.landtick + Attack.waves >= tick) # Hide attacks one tick after the last wave has landed Q = Q.order_by(asc(Attack.id)) attacks = Q.all() Q = session.query(Planet, Target.tick) Q = Q.join(Target.planet) Q = Q.join(Target.user) Q = Q.filter(Planet.active == True) Q = Q.filter(Target.user == user) Q = Q.filter( Target.tick >= tick - 12) # We shouldn't need any bookings 12 ticks after landing Q = Q.order_by(asc(Target.tick), asc(Planet.x), asc(Planet.y), asc(Planet.z)) bookings = [] scans = [] for planet, tock in Q.all(): bookings.append(( planet, tock, [], )) if planet.scan("P"): bookings[-1][2].append(planet.scan("P")) scans.append(planet.scan("P")) if planet.scan("D"): bookings[-1][2].append(planet.scan("D")) scans.append(planet.scan("D")) if planet.scan("A") or planet.scan("U"): bookings[-1][2].append(planet.scan("A") or planet.scan("U")) scans.append(planet.scan("A") or planet.scan("U")) if tock <= tick + Config.getint("Misc", "attjgp") and planet.scan( "J"): bookings[-1][2].append(planet.scan("J")) scans.append(planet.scan("J")) return render("attacks.tpl", request, message=message, attacks=attacks, bookings=bookings, scans=scans)
class alliance(graphs): load = staticmethod(lambda x, y, z, name: Alliance.load(name, exact=True)) title = staticmethod(lambda o: "%s" % (o.name, )) left, right = { 'values': yellow, 'ranks': cyan }, { 'values': green, 'ranks': green } query = { 'values': session.query(AllianceHistory.tick, AllianceHistory.size, AllianceHistory.score, AllianceHistory.members), 'ranks': session.query(AllianceHistory.tick, AllianceHistory.size_rank, AllianceHistory.score_rank, AllianceHistory.points_rank), } plot = { 'values': lambda ax, Q: ( ( ax[1].plot(Q[0], Q[1], yellow)[0], "Size", ), ( ax[2].plot(Q[0], Q[2], green)[0], "Score", ), ( ax[0].plot(Q[0], Q[3], pink)[0], "Members", ), ), 'ranks': lambda ax, Q: ( ( ax[2].plot(Q[0], Q[1], yellow)[0], "Size", ), ( ax[2].plot(Q[0], Q[2], green)[0], "Score", ), ( ax[1].plot(Q[0], Q[3], cyan)[0], "Points", ), ), } ax = { 'values': lambda i, Q: [Q[3], Q[1], Q[2]][i], 'ranks': lambda i, Q: [(0, ), Q[3], Q[2]][i], }
def execute(self, request, user, x, y, h=False, hs=False, ticks=None): galaxy = Galaxy.load(x,y) if galaxy is None: return HttpResponseRedirect(reverse("galaxy_ranks")) ticks = int(ticks or 0) if (h or hs) else 12 if not (h or hs): Q = session.query(Planet, Intel.nick, Alliance.name) Q = Q.outerjoin(Planet.intel) Q = Q.outerjoin(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter(Planet.galaxy == galaxy) Q = Q.order_by(asc(Planet.z)) planets = Q.all() exiles = galaxy.exiles[:10] else: planets, exiles = None, None if not hs: sizediffvalue = GalaxyHistory.rdiff * PA.getint("numbers", "roid_value") valuediffwsizevalue = GalaxyHistory.vdiff - sizediffvalue resvalue = valuediffwsizevalue * PA.getint("numbers", "res_value") shipvalue = valuediffwsizevalue * PA.getint("numbers", "ship_value") xpvalue = GalaxyHistory.xdiff * PA.getint("numbers", "xp_value") Q = session.query(GalaxyHistory, sizediffvalue, valuediffwsizevalue, resvalue, shipvalue, xpvalue, ) Q = Q.filter(GalaxyHistory.current == galaxy) Q = Q.order_by(desc(GalaxyHistory.tick)) history = Q[:ticks] if ticks else Q.all() else: history = None if not h: Q = session.query(GalaxyHistory) Q = Q.filter(or_(GalaxyHistory.hour == 23, GalaxyHistory.tick == Updates.current_tick())) Q = Q.filter(GalaxyHistory.current == galaxy) Q = Q.order_by(desc(GalaxyHistory.tick)) hsummary = Q.all() if hs else Q[:14] else: hsummary = None return render(["galaxy.tpl",["hgalaxy.tpl","hsgalaxy.tpl"][hs]][h or hs], request, galaxy = galaxy, planets = planets, exiles = exiles, history = history, hsummary = hsummary, ticks = ticks, )
def load(name, active=True): Q = session.query(Alliance).filter_by(active=True) alliance = Q.filter(Alliance.name.ilike(name)).first() if alliance is None: alliance = Q.filter(Alliance.name.ilike(name + "%")).first() if alliance is None and active == False: Q = session.query(Alliance) alliance = Q.filter(Alliance.name.ilike(name)).first() if alliance is None: alliance = Q.filter(Alliance.name.ilike(name + "%")).first() return alliance
def execute(self, message, user, params): Q = session.query(Planet.x, Planet.y, count().label('planets')) Q = Q.join(Planet.galaxy) Q = Q.filter(Planet.active == True) Q = Q.filter(Galaxy.private == False) Q = Q.filter(Planet.x < 200) Q = Q.group_by(Planet.x, Planet.y) Q = Q.order_by(desc(count())) subQ = Q.subquery() Q = session.query(subQ.c.planets, count().label('count')) Q = Q.group_by(subQ.c.planets) Q = Q.order_by(asc(subQ.c.planets)) result = Q.all() if len(result) < 1: message.reply("There is no spoon") return gals = 0 bracket = 0 base_bracket_gals = 0 max_planets = 0 for planets, galaxies in result: gals += galaxies bracket = int(gals * .2) for planets, galaxies in result: bracket -= galaxies if bracket < 0: rest_gals = bracket + galaxies total_rest_gals = galaxies rest_planets = planets break max_planets = planets base_bracket_gals += galaxies reply = "Total random galaxies: %s" % (gals, ) reply += " | %s galaxies with a maximum of %s planets guaranteed to be in the exile bracket" % ( base_bracket_gals, max_planets, ) reply += " | Also in the bracket: %s of %s galaxies with %s planets." % ( rest_gals, total_rest_gals, rest_planets, ) message.reply(reply)
def execute(self, request, user, name): alliance = Alliance.load(name) if alliance is None: return HttpResponseRedirect(reverse("alliance_ranks")) ph = aliased(PlanetHistory) members = count().label("members") size = sum(ph.size).label("size") value = sum(ph.value).label("value") score = sum(ph.score).label("score") avg_size = size.op("/")(members).label("avg_size") avg_value = value.op("/")(members).label("avg_value") t10v = count(case(whens=((ph.value_rank <= 10 ,1),), else_=None)).label("t10v") t100v = count(case(whens=((ph.value_rank <= 100 ,1),), else_=None)).label("t100v") pho = aliased(PlanetHistory) sizeo = sum(pho.size).label("sizeo") valueo = sum(pho.value).label("valueo") scoreo = sum(pho.score).label("scoreo") Q = session.query(PlanetHistory.tick.label("tick"), Alliance.id.label("id"), literal_column("rank() OVER (PARTITION BY planet_history.tick ORDER BY sum(planet_history.size) DESC)").label("size_rank"), literal_column("rank() OVER (PARTITION BY planet_history.tick ORDER BY sum(planet_history.value) DESC)").label("value_rank"), ) Q = Q.filter(PlanetHistory.active == True) Q = Q.join(PlanetHistory.current) Q = Q.join(Planet.intel) Q = Q.join(Intel.alliance) Q = Q.group_by(PlanetHistory.tick, Alliance.id) ranks = Q.subquery() Q = session.query(ph.tick, members, size, value, avg_size, avg_value, size-sizeo, value-valueo, score-scoreo, t10v, t100v, ) Q = Q.filter(ph.active == True) Q = Q.join(ph.current) Q = Q.join(Planet.intel) Q = Q.join(Intel.alliance) Q = Q.outerjoin((pho, and_(ph.id==pho.id, ph.tick-1==pho.tick),)) Q = Q.filter(Intel.alliance == alliance) Q = Q.group_by(ph.tick) Q = Q.from_self().add_columns(ranks.c.size_rank, ranks.c.value_rank) Q = Q.outerjoin((ranks, and_(ph.tick == ranks.c.tick, alliance.id == ranks.c.id),)) Q = Q.order_by(desc(ph.tick)) history = Q.all() return render("ialliancehistory.tpl", request, alliance=alliance, members=alliance.intel_members, history=history)
def list_fleets(self, message, user, params): # Check the planet exists planet = Planet.load(*params.group(1, 3, 5)) if planet is None: message.alert("No planet with coords %s:%s:%s" % params.group(1, 3, 5)) return # Find all fleets with a known alliance who have defended this planet OQ = session.query( coalesce(FleetScan.launch_tick, FleetScan.landing_tick), literal_column("'From'").label("dir"), Planet.x, Planet.y, Planet.z, Alliance.name).select_from(FleetScan) OQ = OQ.filter(FleetScan.target_id == planet.id, FleetScan.in_galaxy == False, FleetScan.mission == "Defend") OQ = OQ.join(Intel, FleetScan.owner_id == Intel.planet_id).filter( Intel.alliance_id != None) OQ = OQ.join(Alliance, Intel.alliance_id == Alliance.id).join( Planet, FleetScan.owner_id == Planet.id) # Find all fleets with a known alliance who have been defended by this planet TQ = session.query( coalesce(FleetScan.launch_tick, FleetScan.landing_tick), literal_column("'To '").label("dir"), Planet.x, Planet.y, Planet.z, Alliance.name).select_from(FleetScan) TQ = TQ.filter(FleetScan.owner_id == planet.id, FleetScan.in_galaxy == False, FleetScan.mission == "Defend") TQ = TQ.join(Intel, FleetScan.target_id == Intel.planet_id).filter( Intel.alliance_id != None) TQ = TQ.join(Alliance, Intel.alliance_id == Alliance.id).join( Planet, FleetScan.target_id == Planet.id) # Combine the results into one sorted list results = sorted(OQ.all() + TQ.all(), reverse=True) # Quit now if there are no results if len(results) == 0: message.reply("No suggestions found") return # Reply to the user message.reply("Tick Dir Planet Alliance") limit = int(params.group(6) or 5) for r in results[:limit]: message.reply("%4s %s %-9s %s" % (r[0], r[1], "%s:%s:%s" % (r[2], r[3], r[4]), r[5])) if len(results) > limit: message.reply("%s results not shown (%s total)" % (len(results) - limit, len(results)))
class galaxy(graphs): load = staticmethod(lambda x, y, z, name: Galaxy.load(x, y)) title = staticmethod(lambda o: "%s:%s" % ( o.x, o.y, )) query = { 'values': session.query(GalaxyHistory.tick, GalaxyHistory.size, GalaxyHistory.score, GalaxyHistory.value), 'ranks': session.query(GalaxyHistory.tick, GalaxyHistory.size_rank, GalaxyHistory.score_rank, GalaxyHistory.value_rank), }
def execute(self, message, user, params): tag_count = PA.getint("numbers", "tag_count") alliance = Alliance.load(params.group(1)) if alliance is None: message.reply("No alliance matching '%s' found"%(params.group(1),)) return Q = session.query(sum(Planet.value), sum(Planet.score), sum(Planet.size), sum(Planet.xp), count()) Q = Q.join(Planet.intel) Q = Q.filter(Planet.active == True) Q = Q.filter(Intel.alliance==alliance) Q = Q.group_by(Intel.alliance_id) result = Q.first() if result is None: message.reply("No planets in intel match alliance %s"%(alliance.name,)) return value, score, size, xp, members = result if members <= tag_count: reply="%s Members: %s/%s, Value: %s, Avg: %s," % (alliance.name,members,alliance.members,value,value//members) reply+=" Score: %s, Avg: %s," % (score,score//members) reply+=" Size: %s, Avg: %s, XP: %s, Avg: %s" % (size,size//members,xp,xp//members) message.reply(reply) return Q = session.query(Planet.value, Planet.score, Planet.size, Planet.xp, Intel.alliance_id) Q = Q.join(Planet.intel) Q = Q.filter(Planet.active == True) Q = Q.filter(Intel.alliance==alliance) Q = Q.order_by(desc(Planet.score)) Q = Q.limit(tag_count) Q = Q.from_self(sum(Planet.value), sum(Planet.score), sum(Planet.size), sum(Planet.xp), count()) Q = Q.group_by(Intel.alliance_id) ts_result = Q.first() ts_value, ts_score, ts_size, ts_xp, ts_members = ts_result reply="%s Members: %s/%s (%s)" % (alliance.name,members,alliance.members,ts_members) reply+=", Value: %s (%s), Avg: %s (%s)" % (value,ts_value,value//members,ts_value//ts_members) reply+=", Score: %s (%s), Avg: %s (%s)" % (score,ts_score,score//members,ts_score//ts_members) reply+=", Size: %s (%s), Avg: %s (%s)" % (size,ts_size,size//members,ts_size//ts_members) reply+=", XP: %s (%s), Avg: %s (%s)" % (xp,ts_xp,xp//members,ts_xp//ts_members) message.reply(reply)
def execute(self, request, user, message=None): tick = Updates.current_tick() Q = session.query(Attack) Q = Q.filter( Attack.landtick >= tick - Config.getint("Misc", "attactive")) Q = Q.order_by(asc(Attack.id)) attacks = Q.all() Q = session.query(Planet, Target.tick) Q = Q.join(Target.planet) Q = Q.join(Target.user) Q = Q.filter(Planet.active == True) Q = Q.filter(Target.user == user) Q = Q.filter(Target.tick >= tick - Config.getint("Misc", "attactive")) Q = Q.order_by(asc(Target.tick), asc(Planet.x), asc(Planet.y), asc(Planet.z)) bookings = [] scans = [] for planet, tock in Q.all(): bookings.append(( planet, tock, [], )) if planet.scan("P"): bookings[-1][2].append(planet.scan("P")) scans.append(planet.scan("P")) if planet.scan("D"): bookings[-1][2].append(planet.scan("D")) scans.append(planet.scan("D")) if planet.scan("A") or planet.scan("U"): bookings[-1][2].append(planet.scan("A") or planet.scan("U")) scans.append(planet.scan("A") or planet.scan("U")) if tock <= tick + Config.getint("Misc", "attjgp") and planet.scan( "J"): bookings[-1][2].append(planet.scan("J")) scans.append(planet.scan("J")) return render("attacks.tpl", request, message=message, attacks=attacks, bookings=bookings, scans=scans)
def list_planets(self, message, user, params): oIntel = aliased(Intel) tIntel = aliased(Intel) # Find all planets with unknown alliance, who have been defended by planets (outside of their galaxy) with known alliance TQ = session.query(Planet.x, Planet.y, Planet.z, Alliance.name, count()).select_from(FleetScan).filter(FleetScan.in_galaxy==False, FleetScan.mission=="Defend") TQ = TQ.join(oIntel, FleetScan.owner_id == oIntel.planet_id).join(tIntel, FleetScan.target_id == tIntel.planet_id) TQ = TQ.filter(tIntel.alliance_id == None).filter(oIntel.alliance_id != None) TQ = TQ.join(Alliance, oIntel.alliance_id == Alliance.id).join(Planet, FleetScan.target_id == Planet.id) TQ = TQ.group_by(Planet.x, Planet.y, Planet.z, Alliance.name) # Find all planets with unknown alliance, who have defended planets (outside of their galaxy) with known alliance OQ = session.query(Planet.x, Planet.y, Planet.z, Alliance.name, count()).select_from(FleetScan).filter(FleetScan.in_galaxy==False, FleetScan.mission=="Defend") OQ = OQ.join(oIntel, FleetScan.owner_id == oIntel.planet_id).join(tIntel, FleetScan.target_id == tIntel.planet_id) OQ = OQ.filter(tIntel.alliance_id != None).filter(oIntel.alliance_id == None) OQ = OQ.join(Alliance, tIntel.alliance_id == Alliance.id).join(Planet, FleetScan.owner_id == Planet.id) OQ = OQ.group_by(Planet.x, Planet.y, Planet.z, Alliance.name) # A FULL OUTER JOIN would fit nicely here, but SQLAlchemy doesn't support it and I'm trying to stick with ORM, so we'll use Python # Combine the results into one sorted list results = sorted(TQ.all()+OQ.all()) # Quit now if there are no results if len(results) == 0: message.reply("No suggestions found") return i = 0 while i < (len(results)-1): # Check for planet/alliance combinations that appeared in both lists if results[i][:4] == results[i+1][:4]: r = list(results.pop(i)) # Add the fleet counts (r[i+1] has moved to r[i]) r[4] += results.pop(i)[4] results.insert(i, r) i+=1 # Sort by number of fleets using a helper function from operator import itemgetter results.sort(key=itemgetter(4), reverse=True) # Reply to the user message.reply("Coords Suggestion Fleets") limit = int(params.group(1) or 5) for r in results[:limit]: message.reply("%-9s %-14s %s" % ("%s:%s:%s" % (r[0], r[1], r[2]), r[3], r[4])) if len(results) > limit: message.reply("%s results not shown (%s total)" % (len(results)-limit, len(results)))
def list(self, message, user, params): Q = session.query(func.count().label('count'), func.max(Request.id).label('max_id')) Q = Q.filter(Request.tick > Updates.current_tick() - 5) Q = Q.filter(Request.active == True) Q = Q.group_by(Request.planet_id, Request.scantype) Q = Q.order_by(asc('max_id')) SQ = Q.subquery() Q = session.query(Request, SQ.c.count).join((SQ, and_(Request.id == SQ.c.max_id))) if Q.count() < 1: message.reply("There are no open scan requests") return message.reply(" ".join(map(lambda (request, count): Config.get("Misc", "reqlist").decode("string_escape") % (request.id, request.target.intel.dists if request.target.intel else "0", "/%s" % request.dists if request.dists > 0 else "", request.scantype, request.target.x, request.target.y, request.target.z,), Q.all())))
class planet(graphs): load = staticmethod(lambda x, y, z, name: Planet.load(x, y, z)) title = staticmethod(lambda o: "%s:%s:%s" % ( o.x, o.y, o.z, )) query = { 'values': session.query(PlanetHistory.tick, PlanetHistory.size, PlanetHistory.score, PlanetHistory.value), 'ranks': session.query(PlanetHistory.tick, PlanetHistory.size_rank, PlanetHistory.score_rank, PlanetHistory.value_rank), }
def execute(self, request, user, x, y, z, through): planet = Planet.load(x, y, z) if planet is None: return HttpResponseRedirect(reverse("exiles")) if through: Q = session.query(PlanetExiles) Q = Q.filter( or_( and_(PlanetExiles.oldx == planet.x, PlanetExiles.oldy == planet.y, PlanetExiles.oldz == planet.z), and_(PlanetExiles.newx == planet.x, PlanetExiles.newy == planet.y, PlanetExiles.newz == planet.z))) Q = Q.order_by(desc(PlanetExiles.tick)) exiles = Q.all() else: exiles = planet.exiles return render("exiles.tpl", request, planet=planet, through=through, exiles=exiles)
def load(x, y, active=True): Q = session.query(Galaxy) if active is True: Q = Q.filter_by(active=True) Q = Q.filter_by(x=x, y=y) galaxy = Q.first() return galaxy
def execute(self, message, user, params): reply = "" tick = Updates.current_tick() opts = params.group(1).split() for o in reversed(Config.options("Access")): if ("galmates" not in opts) and (Config.getint("Access", o) == 0): continue Q = session.query(User) Q = Q.filter(User.access == Config.getint("Access", o)) Q = Q.order_by(asc(User.name)) result = Q.all() if len(result) < 1: continue printable = map( lambda (u): "%s%s%s%s%s" % (u.name, ' (' + u.alias + ')' if u.alias else '', " (%d:%d:%d)" % (u.planet.x, u.planet.y, u.planet.z) if "coords" in opts and u.planet is not None else '', " (%s)" % ((u.fleetupdated or 0) - tick) if "defage" in opts else '', " (%s)" % (u.fleetupdated or 0) if "mydef" in opts else ''), result) reply += "%s: " % (o) reply += ', '.join(printable) reply += '\n' message.reply(reply[:-1])
def search_props(self, search): props = self.base_props_selectable() Q = session.query(props.c.id, props.c.person, props.c.vote_result, props.c.type) Q = Q.filter(props.c.person.ilike("%" + search + "%")).order_by( desc(props.c.id)) return Q.all()
def execute(self, message, cmd, usr, prms): if usr is not None: spy = User.load(name=usr) if spy is None: message.reply("No such user '%s'" % (usr, )) return Q = session.query(Command) Q = Q.filter(Command.command.ilike(cmd)) if cmd else Q Q = Q.filter(Command.command_parameters.ilike(prms)) if prms else Q Q = Q.filter(Command.username == spy.name) if usr else Q Q = Q.order_by(desc(Command.id)) result = Q[:5] if len(result) < 1: message.reply( "No logs matching command '%s' with parameters like '%s'" % ( cmd, prms, )) return reply = "\n".join( map( lambda c: "[ %5s | %s | %-30s | %-15s | %-15s | %s]" % ( c.id, c.command, c.command_parameters.strip(), c.nick, c.username, c.command_time.ctime(), ), result)) message.reply(reply)
def execute(self, request, user): Q = session.query(User, Planet, epenis) Q = Q.join(User.planet) Q = Q.join(User.epenis) Q = Q.order_by(asc(epenis.rank)) return render("equeens.tpl", request, queens=Q.all())
def execute(self, message, alliance=None, race=None, sortby="score"): planet = aliased(Planet) planet_intel = aliased(Intel) Q = session.query(planet.x, planet.y, planet.z, planet_intel.nick) Q = Q.outerjoin((planet.intel, planet_intel)) if alliance: Q = Q.filter(planet_intel.alliance == alliance) if race: Q = Q.filter(planet.race == race) if sortby == "xp": Q = Q.order_by(desc(planet.xp)) elif sortby == "size": Q = Q.order_by(desc(planet.size)) elif sortby == "value": Q = Q.order_by(desc(planet.value)) else: Q = Q.order_by(desc(planet.score)) result = Q.all() reply = "Top%s planets" % (" "+race if race is not None else "") if alliance: reply+=" in %s"%(alliance.name,) reply+=" by %s:\n"%(sortby) prev = [] i=0 for x, y, z, nick in result[:10]: i+=1 line = "#%2s %12s%s"%(i, "["+nick+"] " if nick else "", Planet.load(x,y,z)) prev.append(line) message.reply(reply+"\n".join(prev))
def fleet_overview(self): if self.scantype not in ("J",): return from sqlalchemy.sql.functions import min, sum f = aliased(FleetScan) a = aliased(FleetScan) d = aliased(FleetScan) Q = session.query( f.landing_tick, f.landing_tick - min(Scan.tick), count(a.id), coalesce(sum(a.fleet_size), 0), count(d.id), coalesce(sum(d.fleet_size), 0), ) Q = Q.join(f.scan) Q = Q.filter(f.scan == self) Q = Q.outerjoin((a, and_(a.id == f.id, a.mission.ilike("Attack")))) Q = Q.outerjoin((d, and_(d.id == f.id, d.mission.ilike("Defend")))) Q = Q.group_by(f.landing_tick) Q = Q.order_by(asc(f.landing_tick)) return Q.all()
def execute(self, message, user, params): count = self.short2num(params.group(1) or "1") name = params.group(2) ship = Ship.load(name=name) if ship is None: message.alert("No Ship called: %s" % (name,)) return Q = session.query(User, UserFleet) Q = Q.join(User.fleets) Q = Q.filter(User.active == True) Q = Q.filter(User.access >= Config.getint("Access", "member")) Q = Q.filter(UserFleet.ship == ship) Q = Q.filter(UserFleet.ship_count >= count) Q = Q.filter(User.fleetcount > 0) Q = Q.order_by(desc(UserFleet.ship_count)) result = Q.all() if len(result) < 1: message.reply("There are no planets with free fleets and at least %s ships matching '%s'"%(self.num2short(count),ship.name)) return tick = Updates.current_tick() reply = "Fleets matching query: " reply+= " // ".join(map(lambda (u, x): "%s(%s) %s: %s %s ((%s))"%(u.name,u.fleetupdated-tick,u.fleetcount,self.num2short(x.ship_count),ship.name,u.fleetcomment),result)) message.reply(reply)
def execute(self, message, user, params): param = "%" + params.group(1) + "%" Q = session.query(Planet, Intel, Alliance) Q = Q.join(Planet.intel) Q = Q.outerjoin(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter( or_(Intel.nick.ilike(param), and_(Alliance.name.ilike(param), Alliance.active == True))) result = Q[:6] if len(result) < 1: message.reply("No planets in intel matching nick or alliance: %s" % (params.group(1), )) return replies = [] for planet, intel, alliance in result[:5]: reply = "%s:%s:%s (%s)" % (planet.x, planet.y, planet.z, planet.race) reply += " Score: %s Value: %s Size: %s" % ( planet.score, planet.value, planet.size) if intel.nick: reply += " Nick: %s" % (intel.nick, ) if alliance: reply += " Alliance: %s" % (alliance.name, ) if intel.reportchan: reply += " Reportchan: %s" % (intel.reportchan, ) if intel.comment: reply += " Comment: %s" % (intel.comment, ) replies.append(reply) if len(result) > 5: replies[ -1] += " (Too many results to list, please refine your search)" message.reply("\n".join(replies))
def execute(self, message, user, params): param = "%"+params.group(1)+"%" Q = session.query(Planet, Intel, Alliance) Q = Q.join(Planet.intel) Q = Q.outerjoin(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter(or_(Intel.nick.ilike(param), and_(Alliance.name.ilike(param), Alliance.active == True))) result = Q[:6] if len(result) < 1: message.reply("No planets in intel matching nick or alliance: %s"%(params.group(1),)) return replies = [] for planet, intel, alliance in result[:5]: reply="%s:%s:%s (%s)" % (planet.x,planet.y,planet.z,planet.race) reply+=" Score: %s Value: %s Size: %s" % (planet.score,planet.value,planet.size) if intel.nick: reply+=" Nick: %s" % (intel.nick,) if alliance: reply+=" Alliance: %s" % (alliance.name,) if intel.reportchan: reply+=" Reportchan: %s" % (intel.reportchan,) if intel.comment: reply+=" Comment: %s" % (intel.comment,) replies.append(reply) if len(result) > 5: replies[-1]+=" (Too many results to list, please refine your search)" message.reply("\n".join(replies))
def execute(self, message, user, params): search=params.group(1) Q = session.query(FleetLog) if search != "": ship = Ship.load(name=search) if ship is not None: Q = Q.filter(FleetLog.ship == ship) else: u = User.load(search, exact=False, access="member") if u is not None: Q = Q.filter(FleetLog.user == u) else: Q = Q.filter(FleetLog.id == -1) Q = Q.order_by(desc(FleetLog.tick)) result = Q[:10] if len(result) < 1: message.reply("No matches found in the deflog for search '%s'"%(search,)) return tick = Updates.current_tick() reply = ", ".join(map(lambda x:"%s gave %s %s to %s (%s)"%(x.user.name,self.num2short(x.ship_count),x.ship.name,x.taker.name,x.tick-tick),result)) message.reply(reply)
def execute(self, message, user, params): planet = Planet.load(*params.group(1, 3, 5)) if planet is None: message.reply("No planet with coords %s:%s:%s found" % params.group(1, 3, 5)) return Q = session.query(Scan.scantype, max(Scan.tick), count()) Q = Q.filter(Scan.planet == planet) Q = Q.group_by(Scan.scantype) result = Q.all() if len(result) < 1: message.reply("No scans available on %s:%s:%s" % ( planet.x, planet.y, planet.z, )) return prev = [] for type, latest, number in result: prev.append("(%d %s, latest pt%s)" % ( number, type, latest, )) reply = "scans for %s:%s:%s - " % (planet.x, planet.y, planet.z) + ", ".join(prev) message.reply(reply)
def execute(self, message, user, params): if params.group(1)[-6:].lower() == "hideme": notice = "%s" % (params.group(1)[:-6]) else: notice = "(%s) %s" % (user.name, params.group(1)) for chan in session.query(Channel).filter(Channel.userlevel > (Config.getint("Access", "galmate") if "galmate" in Config.options("Access") else 0)).all(): message.notice(notice, chan.name)
def execute(self, request, user, page="1", sort="score"): page = int(page) offset = (page - 1)*50 order = {"score" : (asc(Alliance.score_rank),), "size" : (asc(Alliance.size_rank),), "avg_score" : (asc(Alliance.score_avg_rank),), "avg_size" : (asc(Alliance.size_avg_rank),), "members" : (asc(Alliance.members_rank),), "score_growth" : (desc(Alliance.score_growth),), "size_growth" : (desc(Alliance.size_growth),), "avg_score_growth" : (desc(Alliance.score_avg_growth),), "avg_size_growth" : (desc(Alliance.size_avg_growth),), "score_growth_pc" : (desc(Alliance.score_growth_pc),), "size_growth_pc" : (desc(Alliance.size_growth_pc),), "avg_score_growth_pc" : (desc(Alliance.score_avg_growth_pc),), "avg_size_growth_pc" : (desc(Alliance.size_avg_growth_pc),), } if sort not in order.keys(): sort = "score" order = order.get(sort) Q = session.query(Alliance) Q = Q.filter(Alliance.active == True) count = Q.count() pages = count/50 + int(count%50 > 0) pages = range(1, 1+pages) for o in order: Q = Q.order_by(o) Q = Q.limit(50).offset(offset) return render("alliances.tpl", request, alliances=Q.all(), offset=offset, pages=pages, page=page, sort=sort)
def execute(self, page, uid, pa_id, gid=None): scanlog("Scan: %s (group: %s)" %(pa_id,gid,)) page = decode(page) m = re.search('>([^>]+) on (\d+)\:(\d+)\:(\d+) in tick (\d+)', page) if not m: scanlog("Expired/non-matchinng scan (id: %s)" %(pa_id,)) return scantype = m.group(1)[0].upper() x = int(m.group(2)) y = int(m.group(3)) z = int(m.group(4)) tick = int(m.group(5)) m = re.search("<p class=\"right scan_time\">Scan time: ([^<]*)</p>", page) scantime = m.group(1) planet = Planet.load(x,y,z,) try: Q = session.query(Scan).filter(Scan.pa_id == pa_id).filter(Scan.planet_id == None) if Q.count() > 0: scan = Q.first() else: scan = Scan(pa_id=pa_id, scantype=scantype, tick=tick, time=scantime, group_id=gid, scanner_id=uid) session.add(scan) if planet: planet.scans.append(scan) session.commit() scan_id = scan.id except IntegrityError, e: session.rollback() scanlog("Scan %s may already exist: %s" %(pa_id,str(e),)) return
def execute(self, message, alliance=None, race=None, sortby="score"): planet = aliased(Planet) planet_intel = aliased(Intel) Q = session.query(planet.x, planet.y, planet.z, planet.score, planet.value, planet.size, planet.xp, planet.race, planet_intel.nick) Q = Q.outerjoin(planet.intel, planet_intel) if alliance: Q = Q.filter(planet_intel.alliance == alliance) if race: Q = Q.filter(planet.race == race) Q = Q.group_by(planet.x, planet.y, planet.z, planet.score, planet.value, planet.size, planet.xp, planet.race, planet_intel.nick) if sortby == "xp": Q = Q.order_by(desc(planet.xp)) elif sortby == "size": Q = Q.order_by(desc(planet.size)) elif sortby == "value": Q = Q.order_by(desc(planet.value)) else: Q = Q.order_by(desc(planet.score)) result = Q.all() reply = "Top%s planets" % (" "+race if race is not None else "") if alliance: reply+=" in %s"%(alliance.name,) reply+=" by %s:\n"%(sortby) prev = [] i=0 for x, y, z, score, value, size, xp, race, nick in result[:10]: i+=1 line = "#%s - %s:%s:%s (%s) - Score: %s Value: %s Size: %s XP: %s"%(i,x,y,z,race,score,value,size,xp) if nick: line = "%s Nick: %s"%(line,nick) prev.append(line) print(prev) message.reply(reply+"\n".join(prev))
def execute(self, request, user, sort=None): levels = [] + User.levels if "galmate" in Config.options("Access"): levels.append(("Galaxy", Config.getint("Access","galmate"),)) else: levels.append(("Galaxy", 0,)) if sort is not None: levels = [("All", 0,),] order = {"name" : (asc(Channel.name),), "userlevel" : (desc(Channel.userlevel),), "maxlevel" : (desc(Channel.maxlevel),), } if sort not in order.keys(): sort = "name" order = order.get(sort) channels = [] for level in levels: Q = session.query(Channel.name, Channel.userlevel, Channel.maxlevel) Q = Q.filter(Channel.userlevel >= level[1]) Q = Q.filter(Channel.userlevel < levels[levels.index(level)-1][1]) if levels.index(level) > 0 else Q for o in order: Q = Q.order_by(o) channels.append((level[0], Q.all(),)) return render("channels.tpl", request, accesslist=channels)
def execute(self, message, user, params): # assign param variables alias = params.group(1) if alias is None: m = message.get_msg().split() if len(m) > 1 and m[1] in self.nulls: pass else: message.reply("You are %s, your alias is %s" % ( user.name, user.alias, )) return if alias is not None: if User.load(name=alias) is not None: message.reply( "Your alias is already in use or is someone else's pnick (not allowed). Tough noogies." ) return if session.query(User).filter(User.active == True).filter( User.alias.ilike(alias)).first() is not None: message.reply( "Your alias is already in use or is someone else's pnick (not allowed). Tough noogies." ) return user.alias = alias session.commit() message.reply("Update alias for %s (that's you) to %s" % ( user.name, user.alias, ))
def deny(self, message, user, params): trustee=params.group(1) member = User.load(name=trustee,exact=False) if member is None: message.alert("%s is not a valid user."%(trustee,)) return # Remove a PhoneFriend friends = user.phonefriends if member not in friends: reply="Could not find %s among the people allowed to see your phone number." % (member.name,) else: session.query(PhoneFriend).filter_by(user=user, friend=member).delete(synchronize_session=False) session.commit() reply="Removed %s from the list of people allowed to see your phone number." % (member.name,) message.reply(reply)
def execute(self, message, user, params): search = params.group(1) Q = session.query(FleetLog) if search is not None: ship = Ship.load(name=search) if ship is not None: Q = Q.filter(FleetLog.ship == ship) else: u = User.load(search, exact=False, access="member") if u is not None: Q = Q.filter(FleetLog.user == u) else: Q = Q.filter(FleetLog.id == -1) Q = Q.order_by(desc(FleetLog.tick)) result = Q[:10] if len(result) < 1: message.reply("No matches found in the deflog for search '%s'" % (search, )) return tick = Updates.current_tick() reply = ", ".join( map( lambda x: "%s gave %s %s to %s (%s)" % (x.user.name, self.num2short(x.ship_count), x.ship.name, x. taker.name, x.tick - tick), result)) message.reply(reply)
def execute(self, message, user, params): if params.group(1): u = User.load(params.group(1)) if u: message.reply("%s has %s amps." % (u.name, u.planet.intel.amps)) return else: if not params.group(1).isdigit(): message.reply("No users matching '%s'" % (params.group(1))) return Q = session.query(User, Intel) Q = Q.join(Intel, User.planet_id == Intel.planet_id) if params.group(1): Q = Q.filter(Intel.amps >= int(params.group(1))) else: Q = Q.filter(Intel.amps > 0) Q = Q.order_by(desc(Intel.amps)) Q = Q.limit(10) if Q.count() == 0: message.reply("No scanners found with at least %s amps." % (params.group(1) if params.group(1) else "1")) return reply = "Scanners%s: " % ((" with at least %s amps" % (params.group(1))) if params.group(1) else "") for scanner in Q: reply += "%s: %s " % (scanner[0].name, scanner[1].amps) message.reply(reply[:-2]) return
def execute(self, request, user, page="1", sort="score", race="all"): page = int(page) offset = (page - 1)*50 order = {"score" : (asc(Planet.score_rank),), "value" : (asc(Planet.value_rank),), "size" : (asc(Planet.size_rank),), "xp" : (asc(Planet.xp_rank),), "race" : (asc(Planet.race), asc(Planet.size_rank),), } if sort not in order.keys(): sort = "score" order = order.get(sort) tick = Updates.midnight_tick() Q = session.query(Planet, PlanetHistory, Intel.nick, Alliance.name) Q = Q.outerjoin(Planet.intel) Q = Q.outerjoin(Intel.alliance) Q = Q.outerjoin((PlanetHistory, and_(Planet.id == PlanetHistory.id, PlanetHistory.tick == tick))) Q = Q.filter(Planet.active == True) if race.lower() in PA.options("races"): Q = Q.filter(Planet.race.ilike(race)) else: race = "all" count = Q.count() pages = count/50 + int(count%50 > 0) pages = range(1, 1+pages) for o in order: Q = Q.order_by(o) Q = Q.limit(50).offset(offset) return render("planets.tpl", request, planets=Q.all(), offset=offset, pages=pages, page=page, sort=sort, race=race)
def execute(self, message, user, params): count = self.short2num(params.group(1) or "1") name = params.group(2) ship = Ship.load(name=name) if ship is None: message.alert("No Ship called: %s" % (name, )) return Q = session.query(User, UserFleet) Q = Q.join(User.fleets) Q = Q.filter(User.active == True) Q = Q.filter(User.access >= Config.getint("Access", "member")) Q = Q.filter(UserFleet.ship == ship) Q = Q.filter(UserFleet.ship_count >= count) Q = Q.filter(User.fleetcount > 0) Q = Q.order_by(desc(UserFleet.ship_count)) result = Q.all() if len(result) < 1: message.reply( "There are no planets with free fleets and at least %s ships matching '%s'" % (self.num2short(count), ship.name)) return tick = Updates.current_tick() reply = "Fleets matching query: " reply += ", ".join( map( lambda (u, x): "%s(%s) %s: %s %s" % (u.name, u.fleetupdated - tick, u.fleetcount, self.num2short(x.ship_count), ship.name), result)) message.reply(reply)
def execute(self, request, user, page="1", sort="score"): page = int(page) offset = (page - 1) * 50 order = { "score": (asc(Galaxy.score_rank),), "value": (asc(Galaxy.value_rank),), "size": (asc(Galaxy.size_rank),), "xp": (asc(Galaxy.xp_rank),), } if sort not in order.keys(): sort = "score" order = order.get(sort) tick = Updates.midnight_tick() Q = session.query(Galaxy, GalaxyHistory) Q = Q.outerjoin((GalaxyHistory, and_(Galaxy.id == GalaxyHistory.id, GalaxyHistory.tick == tick))) Q = Q.filter(Galaxy.active == True) count = Q.count() pages = count / 50 + int(count % 50 > 0) pages = range(1, 1 + pages) for o in order: Q = Q.order_by(o) Q = Q.limit(50).offset(offset) return render("galaxies.tpl", request, galaxies=Q.all(), offset=offset, pages=pages, page=page, sort=sort)
def loggedin(message): # Authentication complete if "is now your hidden host" == message.get_msg(): return # This is now deprecated in favour of # setting autoinvite when adding the chan for channel in session.query(Channel): message.privmsg("INVITE %s" % (channel.name,), "P")
def get_log(self, message, user, params): id = params.group(1) c = session.query(Command).filter_by(id=id).first() if c is None: message.reply("ID %s doesn't match a log." % (id,)) return message.reply("[ %5s | %s | %s | %s | %s | %s | %s]" % (c.id, c.command, c.command_parameters.strip(), c.nick, c.username, c.target, c.command_time.ctime(),))