class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__(self, bot, md)
bot.register_module_info(
__name__,
"stats",
"The Junky",
"Stats Retrieval Module",
".01"
)
self._db = Amysql(self.logger)
self._db.setDbCredentialsFromFile(
self.module_path + R"/statsdb.conf", "db")
self._db.start()
# self.clist = [COMMAND_TYPE_PUBLIC, COMMAND_TYPE_TEAM,
# COMMAND_TYPE_FREQ, COMMAND_TYPE_PRIVATE, COMMAND_TYPE_CHAT]
self.clist = [COMMAND_TYPE_PRIVATE]
# self._sql_command_id = bot.register_command(
# '!sql', None, 9, self.clist, "web", "[query]", 'sql it zz')
# self._sqlnl_command_id = bot.register_command(
# '!sqlnl', None, 9, self.clist, "web", "[query]", 'sql it zz')
self._last_jp = bot.register_command(
'!jackpots', None, 0, self.clist, "Stats", "", 'last jackpots won')
self._recs = bot.register_command(
'!recs', None, 0, self.clist, "Stats", "[reset id]", 'top ratios')
self._points = bot.register_command(
'!points', None, 0, self.clist, "Stats", "[reset id]",
'Top points')
self._squads = bot.register_command(
'!squads', None, 0, self.clist, "Stats", "[reset id]",
'top squads')
self._resets = bot.register_command(
'!resets', None, 0, self.clist, "Stats", "", 'recentreset ids')
self.level = logging.DEBUG
self.timer_man = TimerManager.TimerManager()
self.timer_man.set(.01, 1)
self.timer_man.set(300, 2)
self.chat = bot.add_chat("st4ff")
self.cache = {
# !cmd: (Cached_result, time)
"!jackpots": (None, 0, "jackpots.txt"),
"!recs": (None, 0, "recs.txt"),
"!points": (None, 0, "points.txt"),
"!squads": (None, 0, "squads.txt")
}
formatter = logging.Formatter('%(message)s')
handler = LoggingRemoteHandler(logging.DEBUG, bot, "Ratio")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def getMessageTuple(self, event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype, target, event.command.name)
def getResetId(self, event):
if len(event.arguments) > 0:
try:
r = int(event.arguments[0])
if r < 0:
return None
return r
except ValueError:
return None
return None
def handle_events(self, ssbot, event):
if event.type == EVENT_COMMAND:
# if event.command.id in [
# self._sql_command_id, self._sqlnl_command_id]:
# automatically addlimit or not
# if event.command.id == self._sql_command_id:
# limit = " limit 100"
# else:
# limit = ""
# mt = self.get_message_tuple(event)
# db = self._db
# db.query(event.arguments_after[0] + limit, None, mt)
if event.command.id == self._last_jp:
q = """SELECT
id,
IF(
jackpot > 1000000,
concat(round(jackpot / 1000000, 1), "mil"),
concat(round(jackpot/1000, 1), "K")
) AS jp,
IF(
winning_freq < 100,
winning_freq,
"Priv"
) AS freq,
timediff(end_time, start_time) AS runtime
FROM flag_games
WHERE to_days(now()) - to_days(end_time) < 1
ORDER BY jackpot DESC
LIMIT 5"""
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._points:
reset_id = self.getResetId(event)
if reset_id:
ps = " pub_stats_arch"
rs = " and reset_id=" + str(reset_id) + " "
else:
ps = " pub_stats"
rs = ""
q = """SELECT
player.name AS pname,
squad.name AS squad,
flag_points + kill_points AS points
FROM %s ps, player, squad
WHERE
ps.player_id = player.id
AND ps.squad_id = squad.id %s
ORDER BY points DESC
LIMIT 10""" % (ps, rs)
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._resets:
q = "select * from reset order by id desc limit 10"
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._recs:
reset_id = self.getResetId(event)
if reset_id:
ps = " pub_stats_arch"
rs = " and reset_id=" + str(reset_id) + " "
else:
ps = " pub_stats"
rs = ""
q = """SELECT
a.player_id,
b.name,
GetRating(a.Wins, a.Losses) AS `value`,
a.Wins,
a.Losses
FROM %s a, player b
WHERE
a.Wins > 50
AND a.player_id = b.id %s
AND STRCMP(LEFT(b.name, 4), "Bot-")
AND STRCMP(LEFT(b.name, 7), "DevBot-")
ORDER BY value DESC
LIMIT 5""" % (ps, rs)
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._squads:
reset_id = self.getResetId(event)
if reset_id:
ps = " pub_stats_arch"
rs = " and reset_id=" + str(reset_id) + " "
else:
ps = " pub_stats"
rs = ""
q = """SELECT
s.name AS squadname,
GetTopAvg(0, s.id, 10) AS Avg,
count(squad_id) AS members
FROM squad s, %s ps
WHERE
squad_id <> 1
AND s.id = ps.squad_id %s
GROUP BY squad_id HAVING members >= 10
ORDER BY Avg DESC
LIMIT 10""" % (ps, rs)
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
# self.logger.info("tick")
if timer_expired:
# self.logger.info("timer expired")
if timer_expired.data == 1:
# self.logger.info("1")
r = self._db.getResults()
if r: # most of the time this will be None so check first
self.HandleResults(ssbot, event, r)
self.timer_man.set(1, 1) # set it to check again in a sec
elif timer_expired.data == 2:
# self.logger.info("2")
self._db.ping()
self.timer_man.set(300, 2)
def HtmlResultWriter(self, result, filename):
"""
this function will print any result nicely on screen with
proper formatting
"""
f = open(filename, 'w')
if self.rows is None or len(self.rows) == 0:
pass
else:
if not self.description:
f.write("#### NO RESULTS ###")
else:
names = []
lengths = []
for dd in self.description: # iterate over description
names.append(dd[0])
# in case name is bigger then max len of data
lengths.append(len(dd[0]))
for row in self.rows: # get the max length of each column
for i in range(len(row)):
lengths[i] = max(lengths[i], len(str(row[i])))
tb = "-" * (sum(map(int, lengths)) + (len(lengths) * 3) + 1)
fm = "|"
for col in lengths: # make the format string
fm += " %" + str(col) + "s |"
f.write(tb)
f.write((fm % tuple(names)))
f.write(tb)
for row in self.rows: # output the rows
f.write((fm % row))
f.write(tb)
f.close()
def HandleResults(self, ssbot, event, r):
# message like connection error or connected
if r.getType() == AElement.TYPE_MESSAGE:
self.logger.info(r.message)
else:
# if r.query.data[2] in self.cache:
# self.cache[r.query.data[2]] = (
# copy.copy(r), get_tick_count_hs())
r.GenericResultPrettyPrinter(
ssbot, r.query.data[0], r.query.data[1])
def cleanup(self):
self._db.CleanUp()
class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__(self, bot, md)
bot.register_module_info(
__name__,
"MysqLtest",
"The Junky",
"egdldb helper",
".01b"
)
self._db = Amysql(self.logger)
self._db.setDbCredentialsFromFile(
self.module_path + R"/egdldb.conf", "db")
self._db.start()
self.clist = [COMMAND_TYPE_PUBLIC, COMMAND_TYPE_TEAM,
COMMAND_TYPE_FREQ, COMMAND_TYPE_PRIVATE,
COMMAND_TYPE_CHAT]
self.commands = {
# bot.register_command(
# '!sql',
# None,
# 9,
# self.clist,
# "db",
# "[query]",
# 'sql it zz'
# ): (self.cmd_sql, ""),
bot.register_command(
'!sqlnl',
None,
9,
self.clist,
"db",
"[query]",
'sql it zz'
): (self.cmd_sql, "nl"),
bot.register_command(
'!addplayer',
"!ap",
5,
self.clist,
"egdl",
"[name:vp:squadid]",
'create/add new player to current league'
): (self.cmd_ap, ""),
bot.register_command(
'!changeplayer',
"!cp",
5,
self.clist,
"egdl",
"[name:vp:squadid]",
'update existing player'
): (self.cmd_cp, ""),
bot.register_command(
'!deleteplayer',
"!dp",
5,
self.clist,
"egdl",
"[name]",
'update existing player'
): (self.cmd_dp, ""),
bot.register_command(
'!listsquads',
"!ls",
5,
self.clist,
"egdl",
"",
'list squads'
): (self.cmd_ls, ""),
bot.register_command(
'!listplayers',
"!lp",
5,
self.clist,
"egdl",
"[squad]",
'list squads'
): (self.cmd_lp, "")
}
self.level = logging.DEBUG
self.timer_man = TimerManager.TimerManager()
self.timer_man.set(.01, 1)
self.timer_man.set(300, 2)
self.chat = bot.add_chat("st4ff")
formatter = logging.Formatter('%(message)s')
handler = LoggingRemoteHandler(logging.DEBUG, bot, "Ratio")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
@staticmethod
def get_message_tuple(event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype, target)
@staticmethod
def cmd_sql(ssbot, event, param):
ssbot.send_reply(event, "Disabled")
return 0
# if len(event.arguments) >= 1:
# if param and param == "nl": # automatically addlimit or not
# limit = ""
# else:
# limit = " limit 100"
# mt = self.get_message_tuple(event)
# db = self._db
# db.query(event.arguments_after[0] + limit, None, mt)
def cmd_ap(self, ssbot, event, param):
if len(event.arguments) >= 1:
mt = self.get_message_tuple(event)
db = self._db
q = """insert into egdl_players
(userid, name, ip, machineid, vp, status, squad_id)
values (0, %s, 0, 0, %s, 0, %s)
"""
t = event.arguments_after[0].split(":")
if len(t) != 3:
ssbot.send_reply(event, "Could not parse 3 items")
else:
# print t
db.query(q, (t[0], t[1], t[2]), mt)
def cmd_cp(self, ssbot, event, param):
mt = self.get_message_tuple(event)
db = self._db
q = "update egdl_players p set p.vp=%s, p.squad_id=%s where p.name=%s"
t = event.arguments_after[0].split(":")
if len(t) != 3:
ssbot.send_reply(event, "Could not parse 3 items")
else:
# print t
db.query(q, (t[1], t[2], t[0]), mt)
def cmd_dp(self, ssbot, event, param):
if len(event.arguments) >= 1:
mt = self.get_message_tuple(event)
db = self._db
db.query(
"delete from egdl_players where name=%s", (
event.arguments_after[0], ), mt
)
def cmd_ls(self, ssbot, event, param):
mt = self.get_message_tuple(event)
db = self._db
db.query("Select s.* from egdl_squads s limit 100", None, mt)
def cmd_lp(self, ssbot, event, param):
if len(event.arguments) >= 1:
mt = self.get_message_tuple(event)
db = self._db
db.query(
"Select s.name, p.* from egdl_players p, egdl_squads s "
"where s.name=%s and s.id=p.squad_id limit 100", (
event.arguments_after[0], ), mt
)
def handle_events(self, ssbot, event):
if event.type == EVENT_COMMAND:
if event.command.id in self.commands:
c = self.commands[event.command.id]
c[0](ssbot, event, c[1])
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
# self.logger.info("tick")
if timer_expired:
# self.logger.info("timer expired")
if timer_expired.data == 1:
# self.logger.info("1")
r = self._db.getResults()
if r: # most of the time this will be None so check first
self.HandleResults(ssbot, event, r)
self.timer_man.set(1, 1) # set it to check again in a sec
elif timer_expired.data == 2:
# self.logger.info("2")
self._db.ping()
self.timer_man.set(300, 2)
def HandleResults(self, ssbot, event, r):
# message like connection error or connected
if r.getType() == AElement.TYPE_MESSAGE:
self.logger.info(r.message)
else:
r.GenericResultPrettyPrinter(
ssbot, r.query.data[0], r.query.data[1])
def cleanup(self):
self._db.cleanUp()
class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__( self, bot, md)
bot.registerModuleInfo(__name__,"MysqLtest","The Junky","mysqlclient for ss",".01")
self._db = Amysql(self.logger)
self._db.setDbCredentialsFromFile(self.module_path + R"/db.conf","db")
#self._db.setDbCredentialsFromFile(self.module_path + R"/egnetdb.conf","db")
self._db.start()
self.clist = [COMMAND_TYPE_PUBLIC,COMMAND_TYPE_TEAM,COMMAND_TYPE_FREQ,COMMAND_TYPE_PRIVATE,COMMAND_TYPE_CHAT]
self._sql_command_id = bot.registerCommand('!sql',None,9,self.clist,"web","[query]" , 'sql it zz')
self._sqlnl_command_id = bot.registerCommand('!sqlnl',None,9,self.clist,"web","[query]" , 'sql it zz')
self.level = logging.DEBUG
self.timer_man = TimerManager.TimerManager()
self.timer_man.set(.01, 1)
self.timer_man.set(300, 2)
self.chat = bot.addChat("st4ff")
formatter = logging.Formatter('%(message)s')
handler = loggingRemoteHandler(logging.DEBUG,bot,"Ratio")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def getMessageTuple(self,event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype,target)
def HandleEvents(self,ssbot,event):
if event.type == EVENT_COMMAND:
ssbot.sendLvzObjectToggle(event.pname,[(76,True)])
ssbot.sendReply("76 on")
if event.command.id in [self._sql_command_id,self._sqlnl_command_id]:
if event.command.id == self._sql_command_id: #automatically addlimit or not
limit = " limit 100"
else:
limit = ""
mt = self.getMessageTuple(event)
db = self._db
db.query(event.arguments_after[0] + limit , None, mt)
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
#self.logger.info("tick")
if timer_expired:
#self.logger.info("timer expired")
if timer_expired.data == 1:
#self.logger.info("1")
r = self._db.getResults()
if r:# most of the time this will be None so check first
self.HandleResults(ssbot,event,r)
self.timer_man.set(1, 1) #set it to check again in a sec
elif timer_expired.data == 2:
#self.logger.info("2")
self._db.ping()
self.timer_man.set(300, 2)
def HandleResults(self,ssbot,event,r):
if r.getType() == AElement.TYPE_MESSAGE: #message like connection error or connected
self.logger.info(r.message)
else:
r.GenericResultPrettyPrinter(ssbot,r.query.data[0],r.query.data[1])
def Cleanup(self):
pass
class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__(self, bot, md)
bot.register_module_info(__name__, "MysqLtest", "The Junky",
"mysqlclient for ss", ".01")
self._db = Amysql(self.logger)
# self._db.setDbCredentialsFromFile(
# self.module_path + R"/db.conf", "db")
self._db.setDbCredentialsFromFile(self.module_path + R"/egnetdb.conf",
"db")
self._db.start()
self.clist = [
COMMAND_TYPE_PUBLIC, COMMAND_TYPE_TEAM, COMMAND_TYPE_FREQ,
COMMAND_TYPE_PRIVATE, COMMAND_TYPE_CHAT
]
self._sql_command_id = bot.register_command('!sql', None, 9,
self.clist, "web",
"[query]", 'sql it zz')
self._sqlnl_command_id = bot.register_command('!sqlnl', None, 9,
self.clist, "web",
"[query]", 'sql it zz')
self.level = logging.DEBUG
self.timer_man = TimerManager.TimerManager()
self.timer_man.set(.01, 1)
self.timer_man.set(300, 2)
self.chat = bot.add_chat("st4ff")
formatter = logging.Formatter('%(message)s')
handler = LoggingRemoteHandler(logging.DEBUG, bot, "Ratio")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
@staticmethod
def getMessageTuple(event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype, target)
def handle_events(self, ssbot, event):
if event.type == EVENT_COMMAND:
if event.command.id in [
self._sql_command_id, self._sqlnl_command_id
]:
# automatically addlimit or not
limit = ""
if event.command.id == self._sql_command_id:
limit = " limit 100"
mt = self.getMessageTuple(event)
db = self._db
db.query(event.arguments_after[0] + limit, None, mt)
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
# self.logger.info("tick")
if timer_expired:
# self.logger.info("timer expired")
if timer_expired.data == 1:
# self.logger.info("1")
r = self._db.getResults()
if r: # most of the time this will be None so check first
self.HandleResults(ssbot, event, r)
self.timer_man.set(1, 1) # set it to check again in a sec
elif timer_expired.data == 2:
# self.logger.info("2")
self._db.ping()
self.timer_man.set(300, 2)
def HandleResults(self, ssbot, event, r):
# message like connection error or connected
if r.getType() == AElement.TYPE_MESSAGE:
self.logger.info(r.message)
else:
r.GenericResultPrettyPrinter(ssbot, r.query.data[0],
r.query.data[1])
def cleanup(self):
pass
class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__(self, bot, md)
bot.register_module_info(__name__, "stats", "The Junky",
"Stats Retrieval Module", ".01")
self._db = Amysql(self.logger)
self._db.setDbCredentialsFromFile(self.module_path + R"/statsdb.conf",
"db")
self._db.start()
# self.clist = [COMMAND_TYPE_PUBLIC, COMMAND_TYPE_TEAM,
# COMMAND_TYPE_FREQ, COMMAND_TYPE_PRIVATE, COMMAND_TYPE_CHAT]
self.clist = [COMMAND_TYPE_PRIVATE]
# self._sql_command_id = bot.register_command(
# '!sql', None, 9, self.clist, "web", "[query]", 'sql it zz')
# self._sqlnl_command_id = bot.register_command(
# '!sqlnl', None, 9, self.clist, "web", "[query]", 'sql it zz')
self._last_jp = bot.register_command('!jackpots', None, 0, self.clist,
"Stats", "", 'last jackpots won')
self._recs = bot.register_command('!recs', None, 0, self.clist,
"Stats", "[reset id]", 'top ratios')
self._points = bot.register_command('!points', None, 0, self.clist,
"Stats", "[reset id]",
'Top points')
self._squads = bot.register_command('!squads', None, 0, self.clist,
"Stats", "[reset id]",
'top squads')
self._resets = bot.register_command('!resets', None, 0, self.clist,
"Stats", "", 'recentreset ids')
self.level = logging.DEBUG
self.timer_man = TimerManager.TimerManager()
self.timer_man.set(.01, 1)
self.timer_man.set(300, 2)
self.chat = bot.add_chat("st4ff")
self.cache = {
# !cmd: (Cached_result, time)
"!jackpots": (None, 0, "jackpots.txt"),
"!recs": (None, 0, "recs.txt"),
"!points": (None, 0, "points.txt"),
"!squads": (None, 0, "squads.txt")
}
formatter = logging.Formatter('%(message)s')
handler = LoggingRemoteHandler(logging.DEBUG, bot, "Ratio")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def getMessageTuple(self, event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype, target, event.command.name)
def getResetId(self, event):
if len(event.arguments) > 0:
try:
r = int(event.arguments[0])
if r < 0:
return None
return r
except ValueError:
return None
return None
def handle_events(self, ssbot, event):
if event.type == EVENT_COMMAND:
# if event.command.id in [
# self._sql_command_id, self._sqlnl_command_id]:
# automatically addlimit or not
# if event.command.id == self._sql_command_id:
# limit = " limit 100"
# else:
# limit = ""
# mt = self.get_message_tuple(event)
# db = self._db
# db.query(event.arguments_after[0] + limit, None, mt)
if event.command.id == self._last_jp:
q = """SELECT
id,
IF(
jackpot > 1000000,
concat(round(jackpot / 1000000, 1), "mil"),
concat(round(jackpot/1000, 1), "K")
) AS jp,
IF(
winning_freq < 100,
winning_freq,
"Priv"
) AS freq,
timediff(end_time, start_time) AS runtime
FROM flag_games
WHERE to_days(now()) - to_days(end_time) < 1
ORDER BY jackpot DESC
LIMIT 5"""
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._points:
reset_id = self.getResetId(event)
if reset_id:
ps = " pub_stats_arch"
rs = " and reset_id=" + str(reset_id) + " "
else:
ps = " pub_stats"
rs = ""
q = """SELECT
player.name AS pname,
squad.name AS squad,
flag_points + kill_points AS points
FROM %s ps, player, squad
WHERE
ps.player_id = player.id
AND ps.squad_id = squad.id %s
ORDER BY points DESC
LIMIT 10""" % (ps, rs)
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._resets:
q = "select * from reset order by id desc limit 10"
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._recs:
reset_id = self.getResetId(event)
if reset_id:
ps = " pub_stats_arch"
rs = " and reset_id=" + str(reset_id) + " "
else:
ps = " pub_stats"
rs = ""
q = """SELECT
a.player_id,
b.name,
GetRating(a.Wins, a.Losses) AS `value`,
a.Wins,
a.Losses
FROM %s a, player b
WHERE
a.Wins > 50
AND a.player_id = b.id %s
AND STRCMP(LEFT(b.name, 4), "Bot-")
AND STRCMP(LEFT(b.name, 7), "DevBot-")
ORDER BY value DESC
LIMIT 5""" % (ps, rs)
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.command.id == self._squads:
reset_id = self.getResetId(event)
if reset_id:
ps = " pub_stats_arch"
rs = " and reset_id=" + str(reset_id) + " "
else:
ps = " pub_stats"
rs = ""
q = """SELECT
s.name AS squadname,
GetTopAvg(0, s.id, 10) AS Avg,
count(squad_id) AS members
FROM squad s, %s ps
WHERE
squad_id <> 1
AND s.id = ps.squad_id %s
GROUP BY squad_id HAVING members >= 10
ORDER BY Avg DESC
LIMIT 10""" % (ps, rs)
mt = self.getMessageTuple(event)
db = self._db
db.query(q, None, mt)
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
# self.logger.info("tick")
if timer_expired:
# self.logger.info("timer expired")
if timer_expired.data == 1:
# self.logger.info("1")
r = self._db.getResults()
if r: # most of the time this will be None so check first
self.HandleResults(ssbot, event, r)
self.timer_man.set(1, 1) # set it to check again in a sec
elif timer_expired.data == 2:
# self.logger.info("2")
self._db.ping()
self.timer_man.set(300, 2)
def HtmlResultWriter(self, result, filename):
"""
this function will print any result nicely on screen with
proper formatting
"""
f = open(filename, 'w')
if self.rows is None or len(self.rows) == 0:
pass
else:
if not self.description:
f.write("#### NO RESULTS ###")
else:
names = []
lengths = []
for dd in self.description: # iterate over description
names.append(dd[0])
# in case name is bigger then max len of data
lengths.append(len(dd[0]))
for row in self.rows: # get the max length of each column
for i in range(len(row)):
lengths[i] = max(lengths[i], len(str(row[i])))
tb = "-" * (sum(map(int, lengths)) + (len(lengths) * 3) + 1)
fm = "|"
for col in lengths: # make the format string
fm += " %" + str(col) + "s |"
f.write(tb)
f.write((fm % tuple(names)))
f.write(tb)
for row in self.rows: # output the rows
f.write((fm % row))
f.write(tb)
f.close()
def HandleResults(self, ssbot, event, r):
# message like connection error or connected
if r.getType() == AElement.TYPE_MESSAGE:
self.logger.info(r.message)
else:
# if r.query.data[2] in self.cache:
# self.cache[r.query.data[2]] = (
# copy.copy(r), get_tick_count_hs())
r.GenericResultPrettyPrinter(ssbot, r.query.data[0],
r.query.data[1])
def cleanup(self):
self._db.CleanUp()
class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__( self, bot, md)
bot.registerModuleInfo(__name__,"Population Monitoring/Logger","The Junky","logs some pop stats to chart later",".001")
self._db = Amysql(self.logger)
self._db.setDbCredentialsFromFile(self.module_path + R"/popmon.conf","db")
self._db.start()
self.clist = [COMMAND_TYPE_PUBLIC,COMMAND_TYPE_TEAM,COMMAND_TYPE_FREQ,COMMAND_TYPE_PRIVATE,COMMAND_TYPE_CHAT]
self.CID_SP = bot.registerCommand('!showpop',"!sp",2,self.clist,"Pop","limit" , 'show last x entries')
self.CID_SPG = bot.registerCommand('!showpopgraph',"!spg",2,self.clist,"Pop","" , 'graph last 70 pop entries')
self.level = logging.DEBUG
self.chat = bot.addChat("st4ff")
self.QTYPE_SQL=1
self.QTYPE_SPG=2
self.QTYPE_ADDPOP=3
self.timer_man = TimerManager.TimerManager()
self.TID_CHECK_RESULTS=1
self.TID_PING_DB=2
self.TID_PARSE_STATS=3
self.TID_LOG_STATS=4
self.timer_man.set(.01, self.TID_CHECK_RESULTS)
self.timer_man.set(300, self.TID_PING_DB)
self.timer_man.set(30, self.TID_PARSE_STATS)
formatter = logging.Formatter('%(message)s')
handler = loggingPublicHandler(logging.DEBUG,bot,"*bot")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
#gayness because of master bot doesnt auto load all the other classes in the file int ts context
try: #if running in stand alone
self.popStats = PopStats()
except NameError:
self.popStats = md.module.PopStats()
def getMessageTuple(self,event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype,target)
def ResultGraphPrinter(self,res,ssbot,mtype,target):
"""
this function will print any result nicely on screen with proper formatting
"""
ss = BotUtilities.SSmessenger(ssbot,mtype,target)
if res.rows is None or len(res.rows) == 0:
if res.error_msg:
ss.sendMessage("Error: " + str(res.error_msg))
else:
if not res.description:
ss.sendMessage("#### NO RESULTS ###")
else:
min = 9999
max = 0
total = 0
count = 0
for row in res.rows:
pop = row[2]+row[4]+row[6]
if min > pop:
min = pop
if max < pop:
max = pop
total += pop
count+=1
step = -7
data_points = 0
for i in range(140,0,step):
txt = "%-3.3i|" % (i,)
for row in res.rows:
pop = row[2]+row[4]+row[6]
if pop < i and pop >= (step+i):
txt+= "+"
data_points+=1
else:
txt+= " "
if i < min:
break
if data_points:
ss.sendMessage(txt)
ss.sendMessage("000|" + "-" * len(res.rows))
ss.sendMessage("Max:%3i Min:%3i Avg:%3.2f" %(max,min,total/count))
def HandleEvents(self,ssbot,event):
if event.type == EVENT_COMMAND:
if event.command.id == self.CID_SPG:
mt = self.getMessageTuple(event)
# (qtype,message type to respond with,target[playername if priv msg)
qd = (self.QTYPE_SPG,mt[0],mt[1])
db = self._db
db.query("select * from (select * from eg_Bots.population order by id desc limit 70) as pop order by id asc" , None, qd)
if event.command.id == self.CID_SP:
if len(event.arguments) > 0: #automatically addlimit or not
try:
l = int(event.arguments[0])
except:
l = 10
LogException(self.logger)
if l <= 100:
limit = "limit " +str(l)
else:
limit = "limit 100"
else:
limit = "limit 10"
mt = self.getMessageTuple(event)
# (qtype,message type to respond with,target[playername if priv msg)
qd = (self.QTYPE_SQL,mt[0],mt[1])
db = self._db
db.query("select * from eg_Bots.population order by id desc " + limit , None, qd)
if event.type == EVENT_MESSAGE:
if event.message_type == MESSAGE_TYPE_SYSTEM:
if event.message.find(" - Sysop - ") != -1:
if event.message.startswith("DevBot") or event.message.startswith("Bot"):
self.popStats.staff.bots+=1
else:
self.popStats.staff.sysops+=1;
elif event.message.find(" - Mod - ") != -1:
self.popStats.staff.mods+=1
elif event.message.find(" - SMod - ") != -1:
self.popStats.staff.smods+=1
if event.type == EVENT_ARENA_LIST:
for a in event.arena_list:
#a (arena,pop,here)
if a[0][0] >= '0' and a[0][0] <= '9':
self.popStats.arenas.pubCount+=1
self.popStats.arenas.pubPop+= a[1]
elif a[0][0] == '#':
self.popStats.arenas.privCount+=1
self.popStats.arenas.privPop+= a[1]
elif a[0].find(":") != -1:
self.popStats.arenas.peerCount+=1
self.popStats.arenas.peerPop+= a[1]
else:
self.popStats.arenas.nonPubCount+=1
self.popStats.arenas.nonPubPop+= a[1]
self.popStats.pop += a[1]
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
if timer_expired:
if timer_expired.data == self.TID_CHECK_RESULTS:#check for results
r = self._db.getResults()
if r:# most of the time this will be None so check first
self.HandleResults(ssbot,event,r)
self.timer_man.set(1, 1) #set it to check again in a sec
elif timer_expired.data == self.TID_PING_DB:#ping db
self._db.ping()
self.timer_man.set(300, self.TID_PING_DB)
elif timer_expired.data == self.TID_PARSE_STATS: # Clear stats and repopulate
self.popStats.Reset()
ssbot.sendPublicMessage("*listmod")
ssbot.sendPublicMessage("?arena")
self.timer_man.set(1800, self.TID_PARSE_STATS)# do it again in 30 mins
self.timer_man.set(3, self.TID_LOG_STATS) # in 10 secs pop stats will be done send it to db
elif timer_expired.data == self.TID_LOG_STATS: #put in db
a = self.popStats.arenas
s = self.popStats.staff
query = "INSERT INTO eg_bots.Population (pubc,pubp,npubc,npubp,privc,privp,prc,prp,botsc,sysopsc,smodsc,modsc) VALUES (%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i)"
qtp = (a.pubCount,a.pubPop,a.nonPubCount,a.nonPubPop,a.privCount,a.privPop,a.peerCount,a.peerPop,s.bots,s.sysops,s.smods,s.mods)
ssbot.sendPublicMessage(query % qtp)
# (qtype,message type to respond with,target[playername if priv msg)
qdata = (self.QTYPE_ADDPOP,MESSAGE_TYPE_PUBLIC,None)
db = self._db
db.query(query % qtp , None, qdata)
pass
def HandleResults(self,ssbot,event,r):
if r.getType() == AElement.TYPE_MESSAGE: #message like connection error or connected
self.logger.info(r.message)
else:
if r.query.data[0] == self.QTYPE_SQL:
r.GenericResultPrettyPrinter(ssbot,r.query.data[1],r.query.data[2])
if r.query.data[0] == self.QTYPE_SPG:
self.ResultGraphPrinter(r,ssbot,r.query.data[1],r.query.data[2])
elif r.query.data[0] == self.QTYPE_ADDPOP:
pass
#spews to pub only if there is a failure
r.GenericResultPrettyPrinter(ssbot,r.query.data[1],r.query.data[2],True)
def Cleanup(self):
self._db.cleanUp()
class Bot(BotInterface):
def __init__(self, bot, md):
BotInterface.__init__(self, bot, md)
bot.register_module_info(
__name__,
"Population Monitoring/Logger",
"The Junky",
"logs some pop stats to chart later",
".001"
)
self._db = Amysql(self.logger)
self._db.setDbCredentialsFromFile(
self.module_path + R"/popmon.conf", "db")
self._db.start()
self.clist = [
COMMAND_TYPE_PUBLIC,
COMMAND_TYPE_TEAM,
COMMAND_TYPE_FREQ,
COMMAND_TYPE_PRIVATE,
COMMAND_TYPE_CHAT
]
self.CID_SP = bot.register_command(
'!showpop',
"!sp",
2,
self.clist,
"Pop",
"limit",
'show last x entries'
)
self.CID_SPG = bot.register_command(
'!showpopgraph',
"!spg",
2,
self.clist,
"Pop",
"",
'graph last 70 pop entries'
)
self.level = logging.DEBUG
self.chat = bot.add_chat("st4ff")
self.QTYPE_SQL = 1
self.QTYPE_SPG = 2
self.QTYPE_ADDPOP = 3
self.timer_man = TimerManager.TimerManager()
self.TID_CHECK_RESULTS = 1
self.TID_PING_DB = 2
self.TID_PARSE_STATS = 3
self.TID_LOG_STATS = 4
self.timer_man.set(.01, self.TID_CHECK_RESULTS)
self.timer_man.set(300, self.TID_PING_DB)
self.timer_man.set(30, self.TID_PARSE_STATS)
formatter = logging.Formatter('%(message)s')
handler = LoggingPublicHandler(logging.DEBUG, bot, "*bot")
handler.setFormatter(formatter)
self.logger.addHandler(handler)
# gayness because of master bot doesnt auto load all the other
# classes in the file int ts context
try: # if running in stand alone
self.popStats = PopStats()
except NameError:
self.popStats = md.module.PopStats()
def getMessageTuple(self, event):
"""
this data will be used later in pretty printer
when the result is to be printed back to ss
"""
if event.command_type == MESSAGE_TYPE_PRIVATE:
target = event.pname
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_REMOTE:
target = event.pname
mtype = MESSAGE_TYPE_PRIVATE
elif event.command_type == MESSAGE_TYPE_FREQ:
target = event.player.freq
mtype = event.command_type
elif event.command_type == MESSAGE_TYPE_CHAT:
target = event.chat_no
mtype = event.command_type
else:
target = None
mtype = event.command_type
return (mtype, target)
def ResultGraphPrinter(self, res, ssbot, mtype, target):
"""
this function will print any result nicely on screen
with proper formatting
"""
ss = SSmessenger(ssbot, mtype, target)
if res.rows is None or len(res.rows) == 0:
if res.error_msg:
ss.send_message("Error: " + str(res.error_msg))
else:
if not res.description:
ss.send_message("#### NO RESULTS ###")
else:
min = 9999
max = 0
total = 0
count = 0
for row in res.rows:
pop = row[2]+row[4]+row[6]
if min > pop:
min = pop
if max < pop:
max = pop
total += pop
count += 1
step = -7
data_points = 0
for i in range(140, 0, step):
txt = "%-3.3i|" % (i, )
for row in res.rows:
pop = row[2]+row[4]+row[6]
if pop < i and pop >= (step+i):
txt += "+"
data_points += 1
else:
txt += " "
if i < min:
break
if data_points:
ss.send_message(txt)
ss.send_message("000|" + "-" * len(res.rows))
ss.send_message("Max:%3i Min:%3i Avg:%3.2f" %
(max, min, total/count))
def handle_events(self, ssbot, event):
if event.type == EVENT_COMMAND:
if event.command.id == self.CID_SPG:
mt = self.getMessageTuple(event)
# (qtype, message type to respond with,
# target[playername if priv msg)
qd = (self.QTYPE_SPG, mt[0], mt[1])
db = self._db
db.query((
"select * from ("
" select * from eg_Bots.population "
" order by id desc limit 70) as pop "
"order by id asc"
), None, qd)
if event.command.id == self.CID_SP:
# automatically addlimit or not
if len(event.arguments) > 0:
try:
l = int(event.arguments[0])
except:
l = 10
log_exception(self.logger)
if l <= 100:
limit = "limit " + str(l)
else:
limit = "limit 100"
else:
limit = "limit 10"
mt = self.getMessageTuple(event)
# (qtype, message type to respond with,
# target[playername if priv msg)
qd = (self.QTYPE_SQL, mt[0], mt[1])
db = self._db
db.query(
"select * from eg_Bots.population order by id desc "
+ limit, None, qd)
if event.type == EVENT_MESSAGE:
if event.message_type == MESSAGE_TYPE_SYSTEM:
if event.message.find(" - Sysop - ") != -1:
if event.message.startswith("DevBot") or \
event.message.startswith("Bot"):
self.popStats.staff.bots += 1
else:
self.popStats.staff.sysops += 1
elif event.message.find(" - Mod - ") != -1:
self.popStats.staff.mods += 1
elif event.message.find(" - SMod - ") != -1:
self.popStats.staff.smods += 1
if event.type == EVENT_ARENA_LIST:
for a in event.arena_list:
# a (arena, pop, here)
if a[0][0] >= '0' and a[0][0] <= '9':
self.popStats.arenas.pubCount += 1
self.popStats.arenas.pubPop += a[1]
elif a[0][0] == '#':
self.popStats.arenas.privCount += 1
self.popStats.arenas.privPop += a[1]
elif a[0].find(":") != -1:
self.popStats.arenas.peerCount += 1
self.popStats.arenas.peerPop += a[1]
else:
self.popStats.arenas.nonPubCount += 1
self.popStats.arenas.nonPubPop += a[1]
self.popStats.pop += a[1]
elif event.type == EVENT_TICK:
timer_expired = self.timer_man.getExpired() # a timer expired
if timer_expired:
# check for results
if timer_expired.data == self.TID_CHECK_RESULTS:
r = self._db.getResults()
# most of the time this will be None so check first
if r:
self.HandleResults(ssbot, event, r)
# set it to check again in a sec
self.timer_man.set(1, 1)
elif timer_expired.data == self.TID_PING_DB: # ping db
self._db.ping()
self.timer_man.set(300, self.TID_PING_DB)
# Clear stats and repopulate
elif timer_expired.data == self.TID_PARSE_STATS:
self.popStats.Reset()
ssbot.send_public_message("*listmod")
ssbot.send_public_message("?arena")
# do it again in 30 mins
self.timer_man.set(1800, self.TID_PARSE_STATS)
# in 10 secs pop stats will be done send it to db
self.timer_man.set(3, self.TID_LOG_STATS)
elif timer_expired.data == self.TID_LOG_STATS: # put in db
a = self.popStats.arenas
s = self.popStats.staff
query = (
"INSERT INTO eg_bots.Population ("
" pubc, pubp, npubc, npubp, privc, privp, prc, "
" prp, botsc, sysopsc, smodsc, modsc"
") VALUES ("
" %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i"
")"
)
qtp = (
a.pubCount,
a.pubPop,
a.nonPubCount,
a.nonPubPop,
a.privCount,
a.privPop,
a.peerCount,
a.peerPop,
s.bots,
s.sysops,
s.smods,
s.mods
)
ssbot.send_public_message(query % qtp)
# (qtype, message type to respond with,
# target[playername if priv msg)
qdata = (self.QTYPE_ADDPOP, MESSAGE_TYPE_PUBLIC, None)
db = self._db
db.query(query % qtp, None, qdata)
pass
def HandleResults(self, ssbot, event, r):
# message like connection error or connected
if r.getType() == AElement.TYPE_MESSAGE:
self.logger.info(r.message)
else:
if r.query.data[0] == self.QTYPE_SQL:
r.GenericResultPrettyPrinter(
ssbot, r.query.data[1], r.query.data[2])
if r.query.data[0] == self.QTYPE_SPG:
self.ResultGraphPrinter(
r, ssbot, r.query.data[1], r.query.data[2])
elif r.query.data[0] == self.QTYPE_ADDPOP:
pass
# spews to pub only if there is a failure
r.GenericResultPrettyPrinter(
ssbot, r.query.data[1], r.query.data[2], True)
def cleanup(self):
self._db.cleanUp()
