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 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 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, 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, 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(),))
