def execute(self, request, user): if user.planet is not None: tick = Updates.midnight_tick() ph = user.planet.history(tick) else: ph = None return render("index.tpl", request, planet=user.planet, ph=ph)
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, 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, 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 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),), } if sort not in order.keys(): sort = "score" order = order.get(sort) tick = Updates.midnight_tick() Q = session.query(Alliance, AllianceHistory) Q = Q.outerjoin((AllianceHistory, and_(Alliance.id == AllianceHistory.id, AllianceHistory.tick == tick))) 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, 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 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, 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, 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, request, user, sort=None): levels = [] + User.levels if sort is not None: levels = [("All member", levels[-1][1],),] order = {"name" : (asc(User.name),), "access" : (desc(User.access),asc(User.name),), "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.access, 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, id, message=None): attack = Attack.load(id) if attack is None or not attack.active: return HttpResponseRedirect(reverse("attacks")) waves = xrange(attack.landtick, attack.landtick + Attack._waves) show_jgps = attack.landtick <= Updates.current_tick() + Attack._show_jgp_ticks group = [] scans = [] for planet in attack.planets: group.append((planet, [], [],)) if planet.scan("P"): group[-1][1].append(planet.scan("P")) scans.append(planet.scan("P")) if planet.scan("D"): group[-1][1].append(planet.scan("D")) scans.append(planet.scan("D")) if planet.scan("A") or planet.scan("U"): group[-1][1].append(planet.scan("A") or planet.scan("U")) scans.append(planet.scan("A") or planet.scan("U")) if show_jgps and planet.scan("J"): group[-1][1].append(planet.scan("J")) scans.append(planet.scan("J")) bookings = dict([(target.tick, target,) for target in planet.bookings.filter(Target.tick.between(attack.landtick, attack.landtick+4))]) for tick in waves: group[-1][2].append((tick, bookings.get(tick) or (False if show_jgps else None),)) return render("attack.tpl", request, attack=attack, message=message, waves=waves, group=group, scans=scans)
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, 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, 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, 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)
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 server_error(request): # raise ## Uncomment this when shit breaks and you're not getting an error message return HttpResponseServerError( render( "error.tpl", request, msg= "Server error, please report the error to an admin as soon as possible" ))
def execute(self, request, user, x, y, z, h=False, hs=False, ticks=None): planet = Planet.load(x,y,z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) ticks = int(ticks or 0) if (h or hs) else 12 if not hs: sizediffvalue = PlanetHistory.rdiff * PA.getint("numbers", "roid_value") valuediffwsizevalue = PlanetHistory.vdiff - sizediffvalue resvalue = valuediffwsizevalue * PA.getint("numbers", "res_value") shipvalue = valuediffwsizevalue * PA.getint("numbers", "ship_value") xpvalue = PlanetHistory.xdiff * PA.getint("numbers", "xp_value") Q = session.query(PlanetHistory, sizediffvalue, valuediffwsizevalue, resvalue, shipvalue, xpvalue, ) Q = Q.filter(PlanetHistory.current == planet) Q = Q.order_by(desc(PlanetHistory.tick)) history = Q[:ticks] if ticks else Q.all() else: history = None if not (h or hs): landings = session.query(PlanetLandings.hour, count()).filter(PlanetLandings.planet==planet).group_by(PlanetLandings.hour).all() landed = session.query(PlanetLandedOn.hour, count()).filter(PlanetLandedOn.planet==planet).group_by(PlanetLandedOn.hour).all() vdrops = session.query(PlanetValueDrops.hour, count()).filter(PlanetValueDrops.planet==planet).group_by(PlanetValueDrops.hour).all() idles = session.query(PlanetIdles.hour, count()).filter(PlanetIdles.planet==planet).group_by(PlanetIdles.hour).all() hourstats = { 'landings' : dict(landings), 'landingsT' : sum([c for hour,c in landings]), 'landed' : dict(landed), 'landedT' : sum([c for hour,c in landed]), 'vdrops' : dict(vdrops), 'vdropsT' : sum([c for hour,c in vdrops]), 'idles' : dict(idles), 'idlesT' : sum([c for hour,c in idles]), } else: hourstats = None if not h: Q = session.query(PlanetHistory) Q = Q.filter(or_(PlanetHistory.hour == 23, PlanetHistory.tick == Updates.current_tick())) Q = Q.filter(PlanetHistory.current == planet) Q = Q.order_by(desc(PlanetHistory.tick)) hsummary = Q.all() if hs else Q[:14] else: hsummary = None return render(["planet.tpl",["hplanet.tpl","hsplanet.tpl"][hs]][h or hs], request, planet = planet, history = history, hour = datetime.utcnow().hour, hourstats = hourstats, hsummary = hsummary, ticks = ticks, )
def execute(self, request, user, tick, id): Q = session.query(Scan) Q = Q.filter(Scan.tick == tick) Q = Q.filter(Scan.pa_id.ilike("%" + id + "%")) Q = Q.order_by(desc(Scan.id)) scan = Q.first() if scan is None: return HttpResponseRedirect(reverse("scans")) return render("scans/base.tpl", request, scan=scan)
def execute(self, request, user, tick, id): Q = session.query(Scan) Q = Q.filter(Scan.tick == tick) Q = Q.filter(Scan.pa_id.ilike("%"+id+"%")) Q = Q.order_by(desc(Scan.id)) scan = Q.first() if scan is None: return HttpResponseRedirect(reverse("scans")) return render("scans/base.tpl", request, scan=scan)
def execute(self, request, user, x, y, z, type): planet = Planet.load(x,y,z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) scan = planet.scan(type) if scan is None: return HttpResponseRedirect(reverse("planet_scans", kwargs={"x":planet.x, "y":planet.y, "z":planet.z})) return render("scans/base.tpl", request, scan=scan)
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 execute(self, request, user, username="", dashuser=None): dashuser = dashuser or User.load(username or user.name, exact=False) if dashuser is None: return HttpResponseRedirect(reverse("memberlist")) # gimps = dashuser.gimps # mums = dashuser.mums ships = dashuser.fleets.all() phonefriend = user == dashuser or user in dashuser.phonefriends return render("dashboard.tpl", request, dashuser=dashuser, planet=dashuser.planet, ships=ships, phonefriend=phonefriend)
def execute(self, request, user, username="", dashuser=None): dashuser = dashuser or User.load(username or user.name, exact=False) if dashuser is None: return HttpResponseRedirect(reverse("memberlist")) gimps = dashuser.gimps mums = dashuser.mums ships = dashuser.fleets.all() phonefriend = user == dashuser or user in dashuser.phonefriends return render("dashboard.tpl", request, dashuser=dashuser, planet=dashuser.planet, gimps=gimps, mums=mums, ships=ships, phonefriend=phonefriend)
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 execute(self, request, user, id, message=None): attack = Attack.load(id) if attack is None or not attack.active: return HttpResponseRedirect(reverse("attacks")) waves = xrange(attack.landtick, attack.landtick + Attack._waves) show_jgps = attack.landtick <= Updates.current_tick( ) + Attack._show_jgp_ticks group = [] scans = [] for planet in attack.planets: group.append(( planet, [], [], )) if planet.scan("P"): group[-1][1].append(planet.scan("P")) scans.append(planet.scan("P")) if planet.scan("D"): group[-1][1].append(planet.scan("D")) scans.append(planet.scan("D")) if planet.scan("A") or planet.scan("U"): group[-1][1].append(planet.scan("A") or planet.scan("U")) scans.append(planet.scan("A") or planet.scan("U")) if show_jgps and planet.scan("J"): group[-1][1].append(planet.scan("J")) scans.append(planet.scan("J")) bookings = dict([( target.tick, target, ) for target in planet.bookings.filter( Target.tick.between(attack.landtick, attack.landtick + 4))]) for tick in waves: group[-1][2].append(( tick, bookings.get(tick) or (False if show_jgps else None), )) return render("attack.tpl", request, attack=attack, message=message, waves=waves, group=group, scans=scans)
def execute(self, request, user, page="1"): Q = session.query(PlanetExiles) Q = Q.order_by(desc(PlanetExiles.tick), asc(PlanetExiles.oldx), asc(PlanetExiles.oldy), asc(PlanetExiles.oldz), asc(PlanetExiles.newx), asc(PlanetExiles.newy), asc(PlanetExiles.newz)) page = int(page) offset = (page - 1)*50 count = Q.count() pages = count/50 + int(count%50 > 0) pages = range(1, 1+pages) Q = Q.limit(50).offset(offset) return render("exiles.tpl", request, exiles = Q.all(), offset=offset, pages=pages, page=page)
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 execute(self, request, user, x, y, z, types): types = types.upper() planet = Planet.load(x,y,z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) group = [(planet, [],)] scans = [] for type in Scan._scan_types: if type in types: group[-1][1].append(planet.scan(type)) scans.append(planet.scan(type)) return render("scans/planet_types.tpl", request, planet=planet, group=group, scans=scans)
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 execute(self, request, user, x, y, through): galaxy = Galaxy.load(x,y) if galaxy is None: return HttpResponseRedirect(reverse("exiles")) if through: exiles = galaxy.exiles else: Q = session.query(PlanetExiles) Q = Q.join(PlanetExiles.planet) Q = Q.filter(and_(Planet.x == galaxy.x, Planet.y == galaxy.y)) Q = Q.order_by(desc(PlanetExiles.tick)) exiles = Q.all() return render("exiles.tpl", request, galaxy = galaxy, through = through, exiles = exiles)
def execute(self, request, user, tick): Q = session.query(Planet, Scan) Q = Q.join(Scan.planet) Q = Q.filter(Scan.tick == tick) Q = Q.order_by(asc(Planet.x), asc(Planet.y), asc(Planet.z), asc(Scan.scantype), asc(Scan.tick)) result = Q.all() group = [] for planet, scan in result: if len(group) < 1 or group[-1][0] is not planet: group.append((planet, [scan],)) else: group[-1][1].append(scan) return render("scans/tick.tpl", request, tick=tick, group=group)
def execute(self, request, user, x, y): tick = Updates.midnight_tick() galaxy = Galaxy.load(x,y) if galaxy is None: return HttpResponseRedirect(reverse("galaxy_ranks")) gh = galaxy.history(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) Q = Q.filter(Planet.galaxy == galaxy) Q = Q.order_by(asc(Planet.z)) return render("galaxy.tpl", request, galaxy=galaxy, gh=gh, planets=Q.all())
def execute(self, request, user, x, y, z, type): planet = Planet.load(x, y, z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) scan = planet.scan(type) if scan is None: return HttpResponseRedirect( reverse("planet_scans", kwargs={ "x": planet.x, "y": planet.y, "z": planet.z })) return render("scans/base.tpl", request, scan=scan)
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, request, user, name, 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),), "ratio" : (desc(Planet.ratio),), "race" : (asc(Planet.race), asc(Planet.size_rank),), "xyz" : (asc(Planet.x), asc(Planet.y), asc(Planet.z),), "score_growth" : (desc(Planet.score_growth),), "value_growth" : (desc(Planet.value_growth),), "size_growth" : (desc(Planet.size_growth),), "xp_growth" : (desc(Planet.xp_growth),), "score_growth_pc" : (desc(Planet.score_growth_pc),), "value_growth_pc" : (desc(Planet.value_growth_pc),), "size_growth_pc" : (desc(Planet.size_growth_pc),), "xp_growth_pc" : (desc(Planet.xp_growth_pc),), } if sort not in order.keys(): sort = "score" order = order.get(sort) alliance = Alliance.load(name) if alliance is None: return HttpResponseRedirect(reverse("alliance_ranks")) Q = session.query(Planet, Intel.nick, Alliance.name) Q = Q.join(Planet.intel) Q = Q.join(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter(Intel.alliance == alliance) 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("palliance.tpl", request, alliance=alliance, planets=Q.all(), offset=offset, pages=pages, page=page, sort=sort, race=race)
def execute(self, request, user, name, 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),), "ratio" : (desc(Planet.ratio),), "race" : (asc(Planet.race), asc(Planet.size_rank),), "xyz" : (asc(Planet.x), asc(Planet.y), asc(Planet.z),), "score_growth" : (desc(Planet.score_growth),), "value_growth" : (desc(Planet.value_growth),), "size_growth" : (desc(Planet.size_growth),), "xp_growth" : (desc(Planet.xp_growth),), "score_growth_pc" : (desc(Planet.score_growth_pc),), "value_growth_pc" : (desc(Planet.value_growth_pc),), "size_growth_pc" : (desc(Planet.size_growth_pc),), "xp_growth_pc" : (desc(Planet.xp_growth_pc),), } if sort not in order.keys(): sort = "score" order = order.get(sort) alliance = Alliance.load(name) if alliance is None: return HttpResponseRedirect(reverse("alliance_ranks")) Q = session.query(Planet, Intel.nick, Alliance.name) Q = Q.join(Planet.intel) Q = Q.join(Intel.alliance) Q = Q.filter(Planet.active == True) Q = Q.filter(Intel.alliance == alliance) 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("palliance.tpl", request, alliance=alliance, members=alliance.intel_members, planets=Q.all(), offset=offset, pages=pages, page=page, sort=sort, race=race)
def execute(self, request, user, message=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)) mine = Q.all() Q = session.query(Request) Q = Q.filter(Request.tick > tick - 5) Q = Q.filter(Request.active == True) Q = Q.order_by(asc(Request.id)) everyone = Q.all() return render("scans/requests.tpl", request, types=Request._requestable, mine=mine, everyone=everyone, message=message)
def execute(self, request, user, message=None): tick = Updates.current_tick() Q = session.query(Attack) Q = Q.filter(Attack.landtick >= tick - Attack._active_ticks) 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) Q = Q.order_by(asc(Target.tick), asc(Planet.x), asc(Planet.y), asc(Planet.z)) bookings = Q.all() return render("attacks.tpl", request, message=message, attacks=attacks, bookings=bookings)
def execute(self, request, user, page="1", sort="score"): page = int(page) offset = (page - 1) * 50 order = { "score": (asc(Galaxy.score_rank), ), "real_score": (asc(Galaxy.real_score_rank), ), "value": (asc(Galaxy.value_rank), ), "size": (asc(Galaxy.size_rank), ), "planets": (desc(Galaxy.members), ), "ratio": (desc(Galaxy.ratio), ), "xp": (asc(Galaxy.xp_rank), ), "score_growth": (desc(Galaxy.score_growth), ), "real_score_growth": (desc(Galaxy.real_score_growth), ), "value_growth": (desc(Galaxy.value_growth), ), "size_growth": (desc(Galaxy.size_growth), ), "xp_growth": (desc(Galaxy.xp_growth), ), "score_growth_pc": (desc(Galaxy.score_growth_pc), ), "real_score_growth_pc": (desc(Galaxy.real_score_growth_pc), ), "value_growth_pc": (desc(Galaxy.value_growth_pc), ), "size_growth_pc": (desc(Galaxy.size_growth_pc), ), "xp_growth_pc": (desc(Galaxy.xp_growth_pc), ), } if sort not in order.keys(): sort = "score" order = order.get(sort) Q = session.query(Galaxy) 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 execute(self, request, user, tick): Q = session.query(Planet, Scan) Q = Q.join(Scan.planet) Q = Q.filter(Scan.tick == tick) Q = Q.order_by(asc(Planet.x), asc(Planet.y), asc(Planet.z), asc(Scan.scantype), asc(Scan.tick)) result = Q.all() group = [] for planet, scan in result: if len(group) < 1 or group[-1][0] is not planet: group.append(( planet, [scan], )) else: group[-1][1].append(scan) return render("scans/tick.tpl", request, tick=tick, group=group)
def execute(self, request, user, x, y, through): galaxy = Galaxy.load(x, y) if galaxy is None: return HttpResponseRedirect(reverse("exiles")) if through: exiles = galaxy.exiles else: Q = session.query(PlanetExiles) Q = Q.join(PlanetExiles.planet) Q = Q.filter(and_(Planet.x == galaxy.x, Planet.y == galaxy.y)) Q = Q.order_by(desc(PlanetExiles.tick)) exiles = Q.all() return render("exiles.tpl", request, galaxy=galaxy, through=through, exiles=exiles)
def execute(self, request, user, x, y, z): planet = Planet.load(x,y,z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) Q = session.query(Scan) Q = Q.filter(Scan.planet == planet) Q = Q.order_by(desc(Scan.tick), asc(Scan.scantype)) result = Q.all() group = [] for scan in result: if len(group) < 1 or group[-1][0] != scan.tick: group.append((scan.tick, [scan],)) else: group[-1][1].append(scan) return render("scans/planet.tpl", request, planet=planet, group=group)
def execute(self, request, user, id): Q = session.query(Planet, Scan) Q = Q.join(Scan.planet) Q = Q.filter(Scan.group_id.ilike("%"+id+"%")) Q = Q.order_by(asc(Planet.x), asc(Planet.y), asc(Planet.z), asc(Scan.scantype), asc(Scan.tick)) result = Q.all() if len(result) == 0: return HttpResponseRedirect(reverse("scans")) group = [] scans = [] for planet, scan in result: if len(group) < 1 or group[-1][0] is not planet: group.append((planet, [scan],)) else: group[-1][1].append(scan) scans.append(scan) return render("scans/group.tpl", request, group=group, scans=scans)
def execute(self, request, user, name, h=False, hs=False, ticks=None): alliance = Alliance.load(name) if alliance is None: return HttpResponseRedirect(reverse("alliance_ranks")) ticks = int(ticks or 0) if h else 12 if not hs: sizediffvalue = AllianceHistory.rdiff * PA.getint( "numbers", "roid_value") scorediffwsizevalue = AllianceHistory.sdiff - sizediffvalue Q = session.query( AllianceHistory, sizediffvalue, scorediffwsizevalue, ) Q = Q.filter(AllianceHistory.current == alliance) Q = Q.order_by(desc(AllianceHistory.tick)) history = Q[:ticks] if ticks else Q.all() else: history = None if not h: Q = session.query(AllianceHistory) Q = Q.filter( or_(AllianceHistory.hour == 23, AllianceHistory.tick == Updates.current_tick())) Q = Q.filter(AllianceHistory.current == alliance) Q = Q.order_by(desc(AllianceHistory.tick)) hsummary = Q.all() if hs else Q[:14] else: hsummary = None return render( ["alliance.tpl", ["halliance.tpl", "hsalliance.tpl"][hs]][h or hs], request, alliance=alliance, members=alliance.intel_members, history=history, hsummary=hsummary, ticks=ticks, )
def execute(self, request, user, x, y, types): types = types.upper() galaxy = Galaxy.load(x,y) if galaxy is None: return HttpResponseRedirect(reverse("galaxy_ranks")) group = [] scans = [] for planet in galaxy.planets: if not planet.active: continue group.append((planet, [],)) for type in Scan._scan_types: if type in types: group[-1][1].append(planet.scan(type)) scans.append(planet.scan(type)) return render("scans/galaxy.tpl", request, galaxy=galaxy, group=group, scans=scans)
def execute(self, request, user, page="1"): Q = session.query(PlanetExiles) Q = Q.order_by(desc(PlanetExiles.tick), asc(PlanetExiles.oldx), asc(PlanetExiles.oldy), asc(PlanetExiles.oldz), asc(PlanetExiles.newx), asc(PlanetExiles.newy), asc(PlanetExiles.newz)) page = int(page) offset = (page - 1) * 50 count = Q.count() pages = count / 50 + int(count % 50 > 0) pages = range(1, 1 + pages) Q = Q.limit(50).offset(offset) return render("exiles.tpl", request, exiles=Q.all(), offset=offset, pages=pages, page=page)
def run(self, request, **kwargs): user = request.session.user try: if self.check_access(user) is not True: raise UserError response = self.execute(request, user, **kwargs) session = Session() session.add(PageView(page = self.name, full_request = request.get_full_path(), username = user.name, session = request.session.key, hostname = request.get_host(),)) session.commit() return response except UserError: return render("login.tpl", request, msg="F**k off.")
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), ), "ratio": (desc(Alliance.ratio), ), "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, request, user, x, y, z): planet = Planet.load(x, y, z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) Q = session.query(Scan) Q = Q.filter(Scan.planet == planet) Q = Q.order_by(desc(Scan.tick), asc(Scan.scantype)) result = Q.all() group = [] for scan in result: if len(group) < 1 or group[-1][0] != scan.tick: group.append(( scan.tick, [scan], )) else: group[-1][1].append(scan) return render("scans/planet.tpl", request, planet=planet, group=group)
def execute(self, request, user, x, y, z, types): types = types.upper() planet = Planet.load(x, y, z) if planet is None: return HttpResponseRedirect(reverse("planet_ranks")) group = [( planet, [], )] scans = [] for type in Scan._scan_types: if type in types: group[-1][1].append(planet.scan(type)) scans.append(planet.scan(type)) return render("scans/planet_types.tpl", request, planet=planet, group=group, scans=scans)
def execute(self, request, user, message=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)) mine = Q.all() Q = session.query(Request) Q = Q.filter(Request.tick > tick - 5) Q = Q.filter(Request.active == True) Q = Q.order_by(asc(Request.id)) everyone = Q.all() return render("scans/requests.tpl", request, anonscans=Config.getboolean("Misc", "anonscans"), types=Request._requestable, mine=mine, everyone=everyone, message=message)
def execute(self, request, user, id): Q = session.query(Planet, Scan) Q = Q.join(Scan.planet) Q = Q.filter(Scan.group_id.ilike("%" + id + "%")) Q = Q.order_by(asc(Planet.x), asc(Planet.y), asc(Planet.z), asc(Scan.scantype), asc(Scan.tick)) result = Q.all() if len(result) == 0: return HttpResponseRedirect(reverse("scans")) group = [] scans = [] for planet, scan in result: if len(group) < 1 or group[-1][0] is not planet: group.append(( planet, [scan], )) else: group[-1][1].append(scan) scans.append(scan) return render("scans/group.tpl", request, group=group, scans=scans)
def execute(self, request, user, x, y): galaxy = Galaxy.load(x,y) if galaxy is None: return HttpResponseRedirect(reverse("galaxy_ranks")) group = [] scans = [] for planet in galaxy.planets: if not planet.active: continue group.append((planet, [],)) if planet.scan("P"): group[-1][1].append(planet.scan("P")) scans.append(planet.scan("P")) if planet.scan("D"): group[-1][1].append(planet.scan("D")) scans.append(planet.scan("D")) if planet.scan("A") or planet.scan("U"): group[-1][1].append(planet.scan("A") or planet.scan("U")) scans.append(planet.scan("A") or planet.scan("U")) return render("scans/galaxy.tpl", request, galaxy=galaxy, group=group, scans=scans)
def page_not_found(request): return HttpResponseNotFound( render("error.tpl", request, msg="Page not found"))