def invite_decline(inviteid):
my_id = session['my_id']
invite = invites.get_invite_by_id(inviteid)
if not invite:
abort(404)
if invite['user_id'] != my_id:
abort(404)
invites.del_invite_by_id(inviteid)
db.get_conn().commit()
return json.dumps(True)
def run(self):
alliance_query = alliances.AllianceQuery()
all_alliances = alliance_query.getAll()
alliances_names = [item["shortname"] for item in all_alliances]
users_with_alliance = users.UserQuery().find_name_by_alliances(
alliances_names)
query = "SELECT id FROM room_imports WHERE status LIKE 'complete' ORDER BY started_at DESC"
result = db.find_one(query)
self.room_import_id = result[0]
self.conn = get_conn()
self.start()
print(self.id)
for alliance in all_alliances:
users_with_alliance = self.find_name_by_alliances(alliances_names)
members = [
user['name'] for user in users_with_alliance
if user['alliance'] == alliance['shortname']
]
filtered_members = [
user for user in members
if self.get_player_room_count(user) > 0
]
# Not enough members.
if len(filtered_members) < 2:
continue
# Not enough rooms
if self.get_room_count(alliance['shortname']) < 2:
continue
rcl = self.getAllianceRCL(alliance['shortname'])
combined_gcl = sum(
self.getUserGCL(user) for user in filtered_members)
control = sum(
getUserControlPoints(user) for user in filtered_members)
alliance_gcl = self.convertGcl(control)
combined_power = sum(
self.getUserPowerLevel(user) for user in filtered_members)
power = sum(getUserPowerPoints(user) for user in filtered_members)
alliance_power = self.convertPowerToLevel(power)
spawns = self.getAllianceSpawns(alliance['shortname'])
print('%s- %s, %s, %s, %s, %s, %s, %s' %
(alliance['shortname'],
combined_gcl, alliance_gcl, rcl, spawns,
len(filtered_members), alliance_power, combined_power))
self.update(alliance['shortname'],
alliance_gcl, combined_gcl, rcl, spawns,
len(filtered_members), alliance_power, combined_power)
self.finish()
self.conn.commit()
def find_by_shortname(name):
import psycopg2.extras
conn = db.get_conn()
cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
query = "SELECT * FROM alliances where shortname=%s"
cursor.execute(query, (name, ))
result = cursor.fetchone()
return result
def auth(token):
query = "SELECT ign, id, screeps_id FROM users WHERE login_code=%s"
conn = get_conn()
cursor = conn.cursor()
cursor.execute(query, (token, ))
row = cursor.fetchone()
if (row is not None):
session['username'] = row[0]
session['my_id'] = row[1]
session['screeps_id'] = row[2]
return redirect(url_for('index'))
def invite_accept(inviteid):
my_id = session['my_id']
invite = invites.get_invite_by_id(inviteid)
if not invite:
abort(404)
if invite['user_id'] != my_id:
abort(404)
# Add user to appropriate alliance.
users_model.update_alliance_by_user_id(my_id, invite['alliance'])
# Remove all pending invites from user.
invites.del_invites_by_user(my_id)
db.get_conn().commit()
# Return true
return json.dumps(True)
def auth_token(self, name):
id = self.id_from_name(name)
token = None
if id is not None:
token = self.random_token()
query = "UPDATE users SET login_code=%s, login_code_created_at=%s WHERE screeps_id=%s"
conn = get_conn()
cursor = conn.cursor()
cursor.execute(query, (token, datetime.datetime.utcnow(), id))
conn.commit()
return (id, token)
def create_an_alliance(user_id, fullname, shortname, color='#000000'):
conn = db.get_conn()
try:
query = "INSERT INTO alliances(fullname, shortname, color) VALUES(%s, %s, %s)"
cursor = conn.cursor()
cursor.execute(query, (fullname, shortname, color))
query = "UPDATE users SET alliance = %s WHERE id = %s"
cursor.execute(query, (shortname, user_id))
conn.commit()
except (e):
conn.rollback()
def get_player_room_count(player):
query = '''
SELECT COUNT(DISTINCT rooms.name)
FROM rooms,users
WHERE rooms.owner=users.id
AND users.ign=%s
AND rooms.import = (SELECT id
FROM room_imports
ORDER BY id desc
LIMIT 1
);
'''
conn = get_conn()
cursor = conn.cursor()
cursor.execute(query, (player,))
result = cursor.fetchone()
return int(result[0])
def update(self, user_id, username, room, level, shard):
# Store info in db
query = "SELECT id FROM users WHERE screeps_id = %s"
conn = get_conn()
cursor = conn.cursor()
cursor.execute(query, (user_id, ))
row = cursor.fetchone()
if (row is None):
query = "INSERT INTO users(ign, screeps_id) VALUES (%s, %s) RETURNING id"
cursor.execute(query, (username, user_id))
id = cursor.fetchone()[0]
else:
id = row[0]
s = re.search("\d+$", shard)
shard_id = s.group(0)
query = "INSERT INTO rooms(import, name, level, owner, shard) VALUES(%s, %s, %s, %s, %s)"
cursor.execute(query, (self.id, room, level, id, shard_id))
def run(self):
self.start()
api = get_client()
shards = api.get_shards()
for shard in shards:
click.echo('Importing from %s' % (shard,))
queue = []
user_map = {}
roomCount = 0
api_worldsize = api.worldsize(shard)
maxroom = int((api_worldsize['width']-2)/2)
for x in range(1, maxroom + 1):
for y in range(1, maxroom + 1):
for horizontal in ['E', 'W']:
for vertical in ['N', 'S']:
room = "%s%s%s%s" % (horizontal, x, vertical, y)
if self.isNPC(room):
continue
queue.append(room)
if len(queue) < self.queueLimit:
if y < maxroom or x < maxroom:
continue
room_statistics = api.map_stats(queue, 'claim0', shard)
roomCount += self.queueLimit
click.echo(str(roomCount) + " rooms requested")
#self.calls = self.calls + 1
queue = []
for id, user_info in room_statistics['users'].items():
username = user_info['username']
user_map[id] = username
for room, statistics in room_statistics['stats'].items():
if 'own' in statistics:
if 'user' in statistics['own']:
user_id = statistics['own']['user']
level = statistics['own']['level']
self.update(user_id, user_map[user_id], room, level, shard)
conn = get_conn()
self.finish()
conn.commit()
def del_invites_by_alliance(alliance):
query = "DELETE FROM alliance_invites WHERE alliance=(%s)"
conn = db.get_conn()
cursor = conn.cursor()
return cursor.execute(query, (alliance, ))
def clear(self):
conn = get_conn()
cursor = conn.cursor()
cursor.execute("DELETE FROM rooms;")
def insert_username_with_id(name, id):
query = "INSERT INTO users(ign, screeps_id) VALUES(%s, %s)"
conn = db.get_conn()
cursor = conn.cursor()
cursor.execute(query, (name, id))
conn.commit()
def del_invite_by_id(id):
query = "DELETE FROM alliance_invites WHERE id=(%s)"
conn = db.get_conn()
cursor = conn.cursor()
return cursor.execute(query, (id, ))
def del_invites_by_user(user):
query = "DELETE FROM alliance_invites WHERE user_id=(%s)"
conn = db.get_conn()
cursor = conn.cursor()
return cursor.execute(query, (user, ))
def finish(self):
# import, timestamp, status
query = "UPDATE room_imports SET status='complete' WHERE id=(%s)"
conn = get_conn()
cursor = conn.cursor()
cursor.execute(query, (self.id, ))
def start(self):
query = "INSERT INTO room_imports(status) VALUES ('in progress') RETURNING id"
conn = get_conn()
cursor = conn.cursor()
cursor.execute(query)
self.id = cursor.fetchone()[0]