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):
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, 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):
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, 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 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 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"))
