xonstat/models.py

   1 import json
   2 import logging
   3 import math
   4 import sqlalchemy
   5 import sqlalchemy.sql.functions as sfunc
   6 from calendar import timegm
   7 from datetime import timedelta
   8 from sqlalchemy.orm import mapper
   9 from sqlalchemy.orm import scoped_session
  10 from sqlalchemy.orm import sessionmaker
  11 from sqlalchemy.ext.declarative import declarative_base
  12 from xonstat.util import strip_colors, html_colors, pretty_date
  13
  14 log = logging.getLogger(__name__)
  15
  16 DBSession = scoped_session(sessionmaker())
  17 Base = declarative_base()
  18
  19 # define objects for all tables
  20 class Player(object):
  21     def nick_html_colors(self):
  22         if self.nick is None:
  23             return "Anonymous Player"
  24         else:
  25             return html_colors(self.nick)
  26
  27     def nick_strip_colors(self):
  28         if self.nick is None:
  29             return "Anonymous Player"
  30         else:
  31             return strip_colors(self.nick)
  32
  33     def joined_pretty_date(self):
  34         return pretty_date(self.create_dt)
  35
  36     def __repr__(self):
  37         return "<Player(%s, %s)>" % (self.player_id, self.nick.encode('utf-8'))
  38
  39     def to_dict(self):
  40         return {'player_id':self.player_id, 'name':self.nick.encode('utf-8')}
  41
  42
  43 class GameType(object):
  44     def __repr__(self):
  45         return "<GameType(%s, %s, %s)>" % (self.game_type_cd, self.descr, self.active_ind)
  46
  47     def to_dict(self):
  48         return {'game_type_cd':self.game_type_cd, 'name':self.descr, 'active':self.active_ind}
  49
  50
  51 class Weapon(object):
  52     def __repr__(self):
  53         return "<Weapon(%s, %s, %s)>" % (self.weapon_cd, self.descr, self.active_ind)
  54
  55     def to_dict(self):
  56         return {'weapon_cd':self.weapon_cd, 'name':self.descr, 'active':self.active_ind}
  57
  58
  59 class Server(object):
  60     def __init__(self, name=None, hashkey=None, ip_addr=None):
  61         self.name = name
  62         self.hashkey = hashkey
  63         self.ip_addr = ip_addr
  64
  65     def __repr__(self):
  66         return "<Server(%s, %s)>" % (self.server_id, self.name.encode('utf-8'))
  67
  68     def to_dict(self):
  69         return {'server_id':self.server_id, 'name':self.name.encode('utf-8')}
  70
  71     def fuzzy_date(self):
  72         return pretty_date(self.create_dt)
  73
  74     def epoch(self):
  75         return timegm(self.create_dt.timetuple())
  76
  77
  78 class Map(object):
  79     def __init__(self, name=None):
  80         self.name = name
  81
  82     def __repr__(self):
  83         return "<Map(%s, %s, %s)>" % (self.map_id, self.name, self.version)
  84
  85     def to_dict(self):
  86         return {'map_id':self.map_id, 'name':self.name, 'version':self.version}
  87
  88     def fuzzy_date(self):
  89         return pretty_date(self.create_dt)
  90
  91     def epoch(self):
  92         return timegm(self.create_dt.timetuple())
  93
  94
  95 class Game(object):
  96     def __init__(self, game_id=None, start_dt=None, game_type_cd=None,
  97             server_id=None, map_id=None, winner=None):
  98         self.game_id = game_id
  99         self.start_dt = start_dt
 100         self.game_type_cd = game_type_cd
 101         self.server_id = server_id
 102         self.map_id = map_id
 103         self.winner = winner
 104
 105     def __repr__(self):
 106         return "<Game(%s, %s, %s, %s)>" % (self.game_id, self.start_dt, self.game_type_cd, self.server_id)
 107
 108     def to_dict(self):
 109         return {'game_id':self.game_id, 'start':self.start_dt.strftime('%Y-%m-%dT%H:%M:%SZ'), 'game_type_cd':self.game_type_cd, 'server_id':self.server_id}
 110
 111     def fuzzy_date(self):
 112         return pretty_date(self.start_dt)
 113
 114     def epoch(self):
 115         return timegm(self.start_dt.timetuple())
 116
 117
 118 class PlayerGameStat(object):
 119     def __init__(self, player_game_stat_id=None, create_dt=None):
 120         self.player_game_stat_id = player_game_stat_id
 121         self.create_dt = create_dt
 122
 123     def __repr__(self):
 124         return "<PlayerGameStat(%s, %s, %s)>" % (self.player_id, self.game_id, self.create_dt)
 125
 126     def to_dict(self):
 127         return {'player_id':self.player_id, 'game_id':self.game_id, 'create_dt':self.create_dt.strftime('%Y-%m-%dT%H:%M:%SZ')}
 128
 129     def nick_stripped(self):
 130         if self.nick is None:
 131             return "Anonymous Player"
 132         else:
 133             return strip_colors(self.nick)
 134
 135     def nick_html_colors(self):
 136         if self.nick is None:
 137             return "Anonymous Player"
 138         else:
 139             return html_colors(self.nick)
 140
 141     def team_html_color(self):
 142         # blue
 143         if self.team == 5:
 144             return "red"
 145         # red
 146         if self.team == 14:
 147             return "blue"
 148         if self.team == 13:
 149             return "yellow"
 150         if self.team == 10:
 151             return "pink"
 152
 153
 154 class Achievement(object):
 155     def __repr__(self):
 156         return "<Achievement(%s, %s, %s)>" % (self.achievement_cd, self.descr, self.limit)
 157
 158     def to_dict(self):
 159         return {'achievement_cd':self.achievement_cd, 'name':self.descr, 'limit':self.limit}
 160
 161
 162 class PlayerAchievement(object):
 163     def __repr__(self):
 164         return "<PlayerAchievement(%s, %s)>" % (self.player_id, self.achievement_cd)
 165
 166     def to_dict(self):
 167         return {'player_id':self.player_id, 'achievement_cd':self.achievement_cd}
 168
 169
 170 class PlayerWeaponStat(object):
 171     def __init__(self):
 172         self.fired = 0
 173         self.max = 0
 174         self.hit = 0
 175         self.actual = 0
 176         self.frags = 0
 177
 178     def __repr__(self):
 179         return "<PlayerWeaponStat(%s, %s, %s)>" % (self.player_weapon_stats_id, self.player_id, self.game_id)
 180
 181     def to_dict(self):
 182         return {'player_weapon_stats_id':self.player_weapon_stats_id, 'player_id':self.player_id, 'game_id':self.game_id}
 183
 184
 185 class Hashkey(object):
 186     def __init__(self, player_id=None, hashkey=None):
 187         self.player_id = player_id
 188         self.hashkey = hashkey
 189
 190     def __repr__(self):
 191         return "<Hashkey(%s, %s)>" % (self.player_id, self.hashkey)
 192
 193     def to_dict(self):
 194         return {'player_id':self.player_id, 'hashkey':self.hashkey}
 195
 196
 197 class PlayerNick(object):
 198     def __repr__(self):
 199         return "<PlayerNick(%s, %s)>" % (self.player_id, self.stripped_nick)
 200
 201     def to_dict(self):
 202         return {'player_id':self.player_id, 'name':self.stripped_nick}
 203
 204
 205 class PlayerElo(object):
 206     def __init__(self, player_id=None, game_type_cd=None, elo=None):
 207
 208         self.player_id = player_id
 209         self.game_type_cd = game_type_cd
 210         self.elo = elo
 211         self.score = 0
 212         self.games = 0
 213
 214     def __repr__(self):
 215         return "<PlayerElo(pid=%s, gametype=%s, elo=%s)>" % (self.player_id, self.game_type_cd, self.elo)
 216
 217     def to_dict(self):
 218         return {'player_id':self.player_id, 'game_type_cd':self.game_type_cd, 'elo':self.elo}
 219
 220
 221 class PlayerRank(object):
 222
 223     def nick_html_colors(self):
 224         if self.nick is None:
 225             return "Anonymous Player"
 226         else:
 227             return html_colors(self.nick)
 228
 229     def __repr__(self):
 230         return "<PlayerRank(pid=%s, gametype=%s, rank=%s)>" % (self.player_id, self.game_type_cd, self.rank)
 231
 232     def to_dict(self):
 233         return {'player_id':self.player_id, 'game_type_cd':self.game_type_cd, 'rank':self.rank}
 234
 235
 236 def initialize_db(engine=None):
 237     DBSession.configure(bind=engine)
 238     Base.metadata.bind = engine
 239     Base.metadata.create_all(engine)
 240     MetaData = sqlalchemy.MetaData(bind=engine, reflect=True)
 241
 242     # assign all those tables to an object
 243     achievements_table = MetaData.tables['achievements']
 244     cd_achievement_table = MetaData.tables['cd_achievement']
 245     cd_game_type_table = MetaData.tables['cd_game_type']
 246     cd_weapon_table = MetaData.tables['cd_weapon']
 247     db_version_table = MetaData.tables['db_version']
 248     games_table = MetaData.tables['games']
 249     hashkeys_table = MetaData.tables['hashkeys']
 250     maps_table = MetaData.tables['maps']
 251     player_game_stats_table = MetaData.tables['player_game_stats']
 252     players_table = MetaData.tables['players']
 253     player_weapon_stats_table = MetaData.tables['player_weapon_stats']
 254     servers_table = MetaData.tables['servers']
 255     player_nicks_table = MetaData.tables['player_nicks']
 256     player_elos_table = MetaData.tables['player_elos']
 257     player_ranks_table = MetaData.tables['player_ranks']
 258
 259     # now map the tables and the objects together
 260     mapper(PlayerAchievement, achievements_table)
 261     mapper(Achievement, cd_achievement_table)
 262     mapper(GameType, cd_game_type_table)
 263     mapper(Weapon, cd_weapon_table)
 264     mapper(Game, games_table)
 265     mapper(Hashkey, hashkeys_table)
 266     mapper(Map, maps_table)
 267     mapper(PlayerGameStat, player_game_stats_table)
 268     mapper(Player, players_table)
 269     mapper(PlayerWeaponStat, player_weapon_stats_table)
 270     mapper(Server, servers_table)
 271     mapper(PlayerNick, player_nicks_table)
 272     mapper(PlayerElo, player_elos_table)
 273     mapper(PlayerRank, player_ranks_table)