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 datetime as dt
   8 from datetime import timedelta
   9 from sqlalchemy.orm import mapper
  10 from sqlalchemy.orm import scoped_session
  11 from sqlalchemy.orm import sessionmaker
  12 from sqlalchemy.ext.declarative import declarative_base
  13 from xonstat.util import qfont_decode, strip_colors, html_colors, pretty_date
  14
  15 log = logging.getLogger(__name__)
  16
  17 DBSession = scoped_session(sessionmaker())
  18 Base = declarative_base()
  19
  20 # define objects for all tables
  21 class Player(object):
  22     def nick_html_colors(self, limit=None):
  23         if self.nick is None:
  24             return "Anonymous Player"
  25         else:
  26             return html_colors(self.nick, limit)
  27
  28     def nick_strip_colors(self):
  29         if self.nick is None:
  30             return "Anonymous Player"
  31         else:
  32             return strip_colors(self.nick)
  33
  34     def joined_pretty_date(self):
  35         return pretty_date(self.create_dt)
  36
  37     def __repr__(self):
  38         return "<Player(%s, %s)>" % (self.player_id, self.nick.encode('utf-8'))
  39
  40     def to_dict(self):
  41         return {'player_id':self.player_id, 'nick':self.nick,
  42             'joined':self.create_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
  43             'active_ind':self.active_ind, 'location':self.location,
  44             'stripped_nick':qfont_decode(self.stripped_nick)}
  45
  46     def epoch(self):
  47         return timegm(self.create_dt.timetuple())
  48
  49
  50 class GameType(object):
  51     def __repr__(self):
  52         return "<GameType(%s, %s, %s)>" % (self.game_type_cd, self.descr, self.active_ind)
  53
  54     def to_dict(self):
  55         return {'game_type_cd':self.game_type_cd, 'name':self.descr, 'active':self.active_ind}
  56
  57
  58 class Weapon(object):
  59     def __repr__(self):
  60         return "<Weapon(%s, %s, %s)>" % (self.weapon_cd, self.descr, self.active_ind)
  61
  62     def to_dict(self):
  63         return {'weapon_cd':self.weapon_cd, 'name':self.descr, 'active':self.active_ind}
  64
  65
  66 class Server(object):
  67     def __init__(self, name=None, hashkey=None, ip_addr=None):
  68         self.name = name
  69         self.hashkey = hashkey
  70         self.ip_addr = ip_addr
  71         self.create_dt = dt.utcnow()
  72
  73     def __repr__(self):
  74         return "<Server(%s, %s)>" % (self.server_id, self.name.encode('utf-8'))
  75
  76     def to_dict(self):
  77         return {'server_id':self.server_id, 'name':self.name,
  78             'ip_addr':self.ip_addr, 'location':self.location}
  79
  80     def fuzzy_date(self):
  81         return pretty_date(self.create_dt)
  82
  83     def epoch(self):
  84         return timegm(self.create_dt.timetuple())
  85
  86
  87 class Map(object):
  88     def __init__(self, name=None):
  89         self.name = name
  90
  91     def __repr__(self):
  92         return "<Map(%s, %s, %s)>" % (self.map_id, self.name, self.version)
  93
  94     def to_dict(self):
  95         return {'map_id':self.map_id, 'name':self.name, 'version':self.version,}
  96
  97     def fuzzy_date(self):
  98         return pretty_date(self.create_dt)
  99
 100     def epoch(self):
 101         return timegm(self.create_dt.timetuple())
 102
 103
 104 class Game(object):
 105     def __init__(self, game_id=None, start_dt=None, game_type_cd=None,
 106             server_id=None, map_id=None, winner=None):
 107         self.game_id = game_id
 108         self.start_dt = start_dt
 109         self.game_type_cd = game_type_cd
 110         self.server_id = server_id
 111         self.map_id = map_id
 112         self.winner = winner
 113
 114     def __repr__(self):
 115         return "<Game(%s, %s, %s, %s)>" % (self.game_id, self.start_dt, self.game_type_cd, self.server_id)
 116
 117     def to_dict(self):
 118         return {'game_id':self.game_id, 'start':self.start_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
 119                 'game_type_cd':self.game_type_cd, 'server_id':self.server_id}
 120
 121     def fuzzy_date(self):
 122         return pretty_date(self.start_dt)
 123
 124     def epoch(self):
 125         return timegm(self.start_dt.timetuple())
 126
 127
 128 class PlayerGameStat(object):
 129     def __init__(self, player_game_stat_id=None, create_dt=None):
 130         self.player_game_stat_id = player_game_stat_id
 131         self.create_dt = create_dt
 132
 133     def __repr__(self):
 134         return "<PlayerGameStat(%s, %s, %s)>" % (self.player_id, self.game_id, self.create_dt)
 135
 136     def to_dict(self):
 137         return {'player_id':self.player_id, 'game_id':self.game_id,
 138             'create_dt':self.create_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
 139             'alivetime':self.alivetime, 'rank':self.rank, 'score':self.score, 'team':self.team}
 140
 141     def nick_stripped(self):
 142         if self.nick is None:
 143             return "Anonymous Player"
 144         else:
 145             return strip_colors(self.nick)
 146
 147     def nick_html_colors(self, limit=None):
 148         if self.nick is None:
 149             return "Anonymous Player"
 150         else:
 151             return html_colors(self.nick, limit)
 152
 153     def team_html_color(self):
 154         if self.team == 5:
 155             return "red"
 156         if self.team == 14:
 157             return "blue"
 158         if self.team == 13:
 159             return "yellow"
 160         if self.team == 10:
 161             return "pink"
 162
 163
 164 class Achievement(object):
 165     def __repr__(self):
 166         return "<Achievement(%s, %s, %s)>" % (self.achievement_cd, self.descr, self.limit)
 167
 168     def to_dict(self):
 169         return {'achievement_cd':self.achievement_cd, 'name':self.descr, 'limit':self.limit}
 170
 171
 172 class PlayerAchievement(object):
 173     def __repr__(self):
 174         return "<PlayerAchievement(%s, %s)>" % (self.player_id, self.achievement_cd)
 175
 176     def to_dict(self):
 177         return {'player_id':self.player_id, 'achievement_cd':self.achievement_cd}
 178
 179
 180 class PlayerWeaponStat(object):
 181     def __init__(self, player_id=None, game_id=None, weapon_cd=None):
 182         self.player_id = player_id
 183         self.game_id = game_id
 184         self.weapon_cd = weapon_cd
 185         self.fired = 0
 186         self.max = 0
 187         self.hit = 0
 188         self.actual = 0
 189         self.frags = 0
 190
 191     def __repr__(self):
 192         return "<PlayerWeaponStat(%s, %s, %s)>" % (self.player_weapon_stats_id, self.player_id, self.game_id)
 193
 194     def to_dict(self):
 195         return {
 196             'weapon_cd':self.weapon_cd,
 197             'player_weapon_stats_id':self.player_weapon_stats_id,
 198             'player_id':self.player_id,
 199             'game_id':self.game_id,
 200             'fired':self.fired,
 201             'max':self.max,
 202             'hit':self.hit,
 203             'actual':self.actual,
 204             'frags':self.frags,
 205         }
 206
 207
 208 class Hashkey(object):
 209     def __init__(self, player_id=None, hashkey=None):
 210         self.player_id = player_id
 211         self.hashkey = hashkey
 212
 213     def __repr__(self):
 214         return "<Hashkey(%s, %s)>" % (self.player_id, self.hashkey)
 215
 216     def to_dict(self):
 217         return {'player_id':self.player_id, 'hashkey':self.hashkey}
 218
 219
 220 class PlayerNick(object):
 221     def __repr__(self):
 222         return "<PlayerNick(%s, %s)>" % (self.player_id, qfont_decode(self.stripped_nick))
 223
 224     def to_dict(self):
 225         return {'player_id':self.player_id, 'name':qfont_decode(self.stripped_nick)}
 226
 227
 228 class PlayerElo(object):
 229     def __init__(self, player_id=None, game_type_cd=None, elo=None):
 230
 231         self.player_id = player_id
 232         self.game_type_cd = game_type_cd
 233         self.elo = elo
 234         self.score = 0
 235         self.games = 0
 236
 237     def __repr__(self):
 238         return "<PlayerElo(pid=%s, gametype=%s, elo=%s, games=%s)>" % (self.player_id, self.game_type_cd, self.elo, self.games)
 239
 240     def to_dict(self):
 241         return {'player_id':self.player_id, 'game_type_cd':self.game_type_cd, 'elo':self.elo, 'games':self.games}
 242
 243
 244 class PlayerRank(object):
 245
 246     def nick_html_colors(self, limit=None):
 247         if self.nick is None:
 248             return "Anonymous Player"
 249         else:
 250             return html_colors(self.nick, limit)
 251
 252     def __repr__(self):
 253         return "<PlayerRank(pid=%s, gametype=%s, rank=%s)>" % (self.player_id, self.game_type_cd, self.rank)
 254
 255     def to_dict(self):
 256         return {'player_id':self.player_id, 'game_type_cd':self.game_type_cd, 'rank':self.rank}
 257
 258
 259 class PlayerCaptime(object):
 260     def __init__(self, player_id=None, game_id=None, map_id=None,
 261             fastest_cap=None, mod=None):
 262         self.player_id = player_id
 263         self.game_id = game_id
 264         self.map_id = map_id
 265         self.fastest_cap = fastest_cap
 266         self.mod = mod
 267
 268     def __repr__(self):
 269         return "<PlayerCaptime(pid=%s, map_id=%s, mod=%s)>" % (self.player_id,
 270                 self.map_id, self.mod)
 271
 272     def fuzzy_date(self):
 273         return pretty_date(self.create_dt)
 274
 275     def epoch(self):
 276         return timegm(self.create_dt.timetuple())
 277
 278
 279 class SummaryStat(object):
 280     def __repr__(self):
 281         return "<SummaryStat(total_players=%s, total_games=%s, total_servers=%s)>" % (self.total_players, self.total_games, self.total_servers)
 282
 283
 284 class TeamGameStat(object):
 285     def __init__(self, team_game_stat_id=None, create_dt=None):
 286         self.team_game_stat_id = team_game_stat_id
 287         self.create_dt = create_dt
 288
 289     def __repr__(self):
 290         return "<TeamGameStat(%s, %s, %s)>" % (self.team_game_stat_id, self.game_id, self.team)
 291
 292     def to_dict(self):
 293         return {
 294             'team_game_stat_id':self.team_game_stat_id,
 295             'game_id':self.game_id,
 296             'team':self.team,
 297             'score':self.score,
 298             'rounds':self.rounds,
 299             'caps':self.caps,
 300             'create_dt':self.create_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
 301         }
 302
 303     def team_html_color(self):
 304         if self.team == 5:
 305             return "red"
 306         if self.team == 14:
 307             return "blue"
 308         if self.team == 13:
 309             return "yellow"
 310         if self.team == 10:
 311             return "pink"
 312
 313
 314 class PlayerGameAnticheat(object):
 315     def __init__(self, player_id=None, game_id=None, key=None,
 316             value=None, create_dt=None):
 317         self.player_id                = player_id
 318         self.game_id                  = game_id
 319         self.key                      = key
 320         self.value                    = value
 321         self.create_dt                = create_dt
 322
 323     def __repr__(self):
 324         return "<PlayerGameAnticheat(%s, %d)>" % (self.key, self.value)
 325
 326
 327 class PlayerGroups(object):
 328     def __init__(self, player_id=None, group_name=None):
 329         self.player_id  = player_id
 330         self.group_name = group_name
 331
 332     def __repr__(self):
 333         return "<PlayerGroups(%s, %s)>" % (self.player_id, self.group_name)
 334
 335
 336 class MapCapTime(object):
 337     """Fastest flag capture times per map, assembled from a SQLAlchemy query"""
 338     def __init__(self, row):
 339         self.fastest_cap          = row.fastest_cap
 340         self.create_dt            = row.create_dt
 341         self.create_dt_epoch      = timegm(row.create_dt.timetuple())
 342         self.create_dt_fuzzy      = pretty_date(row.create_dt)
 343         self.player_id            = row.player_id
 344         self.player_nick          = row.player_nick
 345         self.player_nick_stripped = strip_colors(row.player_nick)
 346         self.player_nick_html     = html_colors(row.player_nick)
 347         self.game_id              = row.game_id
 348         self.server_id            = row.server_id
 349         self.server_name          = row.server_name
 350
 351     def to_dict(self):
 352         return {
 353             "fastest_cap"          : self.fastest_cap.total_seconds(),
 354             "create_dt_epoch"      : self.create_dt_epoch,
 355             "create_dt_fuzzy"      : self.create_dt_fuzzy,
 356             "player_id"            : self.player_id,
 357             "player_nick"          : self.player_nick,
 358             "player_nick_stripped" : self.player_nick_stripped,
 359             "game_id"              : self.game_id,
 360             "server_id"            : self.server_id,
 361             "server_name"          : self.server_name,
 362             }
 363
 364
 365 class PlayerCapTime(object):
 366     """Fastest flag capture times per player, assembled from a SQLAlchemy query"""
 367     def __init__(self, row):
 368         self.fastest_cap = row.fastest_cap
 369         self.create_dt = row.create_dt
 370         self.create_dt_epoch = timegm(row.create_dt.timetuple())
 371         self.create_dt_fuzzy = pretty_date(row.create_dt)
 372         self.player_id = row.player_id
 373         self.game_id = row.game_id
 374         self.map_id = row.map_id
 375         self.map_name = row.map_name
 376         self.server_id = row.server_id
 377         self.server_name = row.server_name
 378
 379     def to_dict(self):
 380         return {
 381             "fastest_cap" : self.fastest_cap.total_seconds(),
 382             "create_dt_epoch": self.create_dt_epoch,
 383             "create_dt_fuzzy": self.create_dt_fuzzy,
 384             "game_id":self.game_id,
 385             "map_id": self.map_id,
 386             "map_name": self.map_name,
 387             "server_id": self.server_id,
 388             "server_name": self.server_name,
 389             }
 390
 391
 392 class ActivePlayer(object):
 393     def __init__(self, sort_order=None, player_id=None, nick=None,
 394             alivetime=None):
 395         self.sort_order = sort_order
 396         self.player_id = player_id
 397         self.nick = nick
 398         self.alivetime = alivetime
 399
 400     def nick_html_colors(self):
 401         return html_colors(self.nick)
 402
 403     def __repr__(self):
 404         return "<ActivePlayer(%s, %s)>" % (self.sort_order, self.player_id)
 405
 406
 407 class ActiveServer(object):
 408     def __init__(self, sort_order=None, server_id=None, server_name=None,
 409             games=None):
 410         self.sort_order = sort_order
 411         self.server_id = server_id
 412         self.server_name = server_name
 413         self.games = games
 414
 415     def __repr__(self):
 416         return "<ActiveServer(%s, %s)>" % (self.sort_order, self.server_id)
 417
 418
 419 class ActiveMap(object):
 420     def __init__(self, sort_order=None, map_id=None, map_name=None,
 421             games=None):
 422         self.sort_order = sort_order
 423         self.map_id = map_id
 424         self.map_name = map_name
 425         self.games = games
 426
 427     def __repr__(self):
 428         return "<ActiveMap(%s, %s)>" % (self.sort_order, self.map_id)
 429
 430
 431 class PlayerMedal(object):
 432     def __repr__(self):
 433         return "<PlayerRank(pid=%s, place=%s, alt=%s)>" % (self.player_id,
 434                 self.place, self.alt)
 435
 436
 437 def initialize_db(engine=None):
 438     DBSession.configure(bind=engine)
 439     Base.metadata.bind = engine
 440     Base.metadata.create_all(engine)
 441     MetaData = sqlalchemy.MetaData(bind=engine)
 442     MetaData.reflect()
 443
 444     # assign all those tables to an object
 445     achievements_table = MetaData.tables['achievements']
 446     cd_achievement_table = MetaData.tables['cd_achievement']
 447     cd_game_type_table = MetaData.tables['cd_game_type']
 448     cd_weapon_table = MetaData.tables['cd_weapon']
 449     db_version_table = MetaData.tables['db_version']
 450     games_table = MetaData.tables['games']
 451     hashkeys_table = MetaData.tables['hashkeys']
 452     maps_table = MetaData.tables['maps']
 453     player_game_stats_table = MetaData.tables['player_game_stats']
 454     players_table = MetaData.tables['players']
 455     player_weapon_stats_table = MetaData.tables['player_weapon_stats']
 456     servers_table = MetaData.tables['servers']
 457     player_nicks_table = MetaData.tables['player_nicks']
 458     player_elos_table = MetaData.tables['player_elos']
 459     player_ranks_table = MetaData.tables['player_ranks']
 460     player_captimes_table = MetaData.tables['player_map_captimes']
 461     summary_stats_table = MetaData.tables['summary_stats']
 462     team_game_stats_table = MetaData.tables['team_game_stats']
 463     player_game_anticheats_table = MetaData.tables['player_game_anticheats']
 464     player_groups_table = MetaData.tables['player_groups']
 465     active_players_table = MetaData.tables['active_players_mv']
 466     active_servers_table = MetaData.tables['active_servers_mv']
 467     active_maps_table = MetaData.tables['active_maps_mv']
 468     player_medals_table = MetaData.tables['player_medals']
 469
 470     # now map the tables and the objects together
 471     mapper(PlayerAchievement, achievements_table)
 472     mapper(Achievement, cd_achievement_table)
 473     mapper(GameType, cd_game_type_table)
 474     mapper(Weapon, cd_weapon_table)
 475     mapper(Game, games_table)
 476     mapper(Hashkey, hashkeys_table)
 477     mapper(Map, maps_table)
 478     mapper(PlayerGameStat, player_game_stats_table)
 479     mapper(Player, players_table)
 480     mapper(PlayerWeaponStat, player_weapon_stats_table)
 481     mapper(Server, servers_table)
 482     mapper(PlayerNick, player_nicks_table)
 483     mapper(PlayerElo, player_elos_table)
 484     mapper(PlayerRank, player_ranks_table)
 485     mapper(PlayerCaptime, player_captimes_table)
 486     mapper(SummaryStat, summary_stats_table)
 487     mapper(TeamGameStat, team_game_stats_table)
 488     mapper(PlayerGameAnticheat, player_game_anticheats_table)
 489     mapper(PlayerGroups, player_groups_table)
 490     mapper(ActivePlayer, active_players_table)
 491     mapper(ActiveServer, active_servers_table)
 492     mapper(ActiveMap, active_maps_table)
 493     mapper(PlayerMedal, player_medals_table)