async def initial_handler(self, msg, chat_handler):
if len(Group.select().where(Group.group_name == get_config_item(
"OPS_GROUP", "ncdot"))) > 0:
ncdotgroup = Group.select().where(
Group.group_name == get_config_item("OPS_GROUP",
"ncdot")).get()
if len(GroupMembership.select().where(
GroupMembership.group == ncdotgroup, GroupMembership.user
== chat_handler.user)) > 0:
try:
r = await aiohttp.get(
get_config_item("OPS_JSON_URL", 'ncdotopsurl'))
self._ops = (await r.json())["ops"]
self.finished()
if self._ops != []:
await self.send_template(chat_handler, "OPS")
else:
await chat_handler.sender.sendMessage("No ops planned")
except:
traceback.print_exc()
self.finished()
await chat_handler.sender.sendMessage("error getting !ops")
else:
self.finished()
await chat_handler.sender.sendMessage(
"you are not in ncdot group")
else:
self.finished()
await chat_handler.sender.sendMessage("no ncdot group")
def handle_group_name(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name))>0:
yield from chat_handler.sender.sendMessage(_s["msg_groupname_exists"])
else:
self.finished()
Group.create(group_name=group_name)
yield from chat_handler.sender.sendMessage(_s["msg_group_created"])
def initial_handler(self, msg, chat_handler):
if len(Group.select()) > 0:
groups = "Here are the groups:\n"
for group in Group.select():
groups += " " + group.group_name + "\n"
self.finished()
yield from chat_handler.sender.sendMessage(groups)
else:
self.finished()
yield from chat_handler.sender.sendMessage(_s["msg_nogroups"])
def handle_group_name(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
yield from chat_handler.sender.sendMessage(
_s["msg_groupname_exists"])
else:
self.finished()
Group.create(group_name=group_name)
yield from chat_handler.sender.sendMessage(
_s["msg_group_created"])
def initial_handler(self, msg, chat_handler):
if len(Group.select()) > 0:
groups = "Please respond with the name of the group you would like to link\n\n"
options = []
for group in Group.select():
groups += " " +group.group_name + "\n"
options.append(group.group_name)
self.current_handler = self.handle_group
yield from chat_handler.sender.sendMessage(groups, reply_markup={'keyboard': [options]})
else:
yield from chat_handler.sender.sendMessage(_s["msg_nogroups"])
def initial_handler(self, msg, chat_handler):
if len(Group.select()) > 0:
groups = "Please respond with the name of the group you would like to link\n\n"
options = []
for group in Group.select():
groups += " " + group.group_name + "\n"
options.append(group.group_name)
self.current_handler = self.handle_group
yield from chat_handler.sender.sendMessage(
groups, reply_markup={'keyboard': [options]})
else:
yield from chat_handler.sender.sendMessage(_s["msg_nogroups"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
self._group = Group.select().where(Group.group_name == group_name).get()
mute_instance = Mute.select().where(Mute.user == chat_handler.user, Mute.group == self._group).get()
mute_instance.delete_instance()
self.finished()
yield from chat_handler.sender.sendMessage(_s["msg_groupunmuted"], reply_markup={"hide_keyboard": True})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg,chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name==group_name)) > 0:
corps = [c.corporation_name for c in Character.select()]
corp_count = [t[0] for t in Counter(corps).most_common(10)]
options = [corp_count[:5], corp_count[5:]]
self._group = Group.select().where(Group.group_name==group_name).get()
self.current_handler = self.handle_corp
yield from chat_handler.sender.sendMessage(_s["msg_whichingamecorp"],reply_markup={'keyboard': options})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg,chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name==group_name)) > 0:
shiptypes = [c.shiptype_name for c in Character.select()]
shiptypes_count = [t[0] for t in Counter(shiptypes).most_common(10) if t[0] != ""]
options = [shiptypes_count[:5], shiptypes_count[5:]]
self._group = Group.select().where(Group.group_name == group_name).get()
self.current_handler = self.handle_shiptype
yield from chat_handler.sender.sendMessage(_s["msg_whichingameship"],reply_markup={'keyboard': options})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
async def legacy_pinggroup(request):
group = request.match_info.get('group', "group")
text = request.match_info.get('text', "'message'")
fromp = request.match_info.get('from', "'message'")
tasks = []
success = 0
# look up the group, for each user id send the 'message'
for member in GroupMembership.select().where(
GroupMembership.group == Group.select().where(
Group.legacy_name == group)):
tasks.append(
safe_send(member.user.telegram_id,
"Ping from " + fromp + " to " + group + ":\n\n" + text))
success += 1
def chunks(l, n):
for i in range(0, len(l), n):
yield l[i:i + n]
start_time = time.time()
for chunk in chunks(tasks, get_config_item("THROTTLE_CHUNK_SIZE", 20)):
await asyncio.gather(*chunk)
await asyncio.sleep(1)
elapsed = time.time() - start_time
rounded = math.floor(elapsed * 100) / 100
msg = "Ping sent to " + str(success) + " users in " + str(
rounded) + " seconds"
return web.Response(body=msg.encode('utf-8'))
async def legacy_pinggroup(request):
group = request.match_info.get('group', "group")
text = request.match_info.get('text', "'message'")
fromp = request.match_info.get('from', "'message'")
tasks = []
success = 0
# look up the group, for each user id send the 'message'
for member in GroupMembership.select().where(GroupMembership.group==Group.select().where(Group.legacy_name == group)):
tasks.append(safe_send(member.user.telegram_id, "Ping from "+fromp+" to "+group+":\n\n"+text))
success += 1
def chunks(l, n):
for i in range(0, len(l), n):
yield l[i:i+n]
start_time = time.time()
for chunk in chunks(tasks, get_config_item("THROTTLE_CHUNK_SIZE", 20)):
await asyncio.gather(*chunk)
await asyncio.sleep(1)
elapsed = time.time() - start_time
rounded = math.floor(elapsed*100)/100
msg = "Ping sent to "+str(success)+" users in "+str(rounded)+" seconds"
return web.Response(body=msg.encode('utf-8'))
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg,chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
self._group = Group.select().where(Group.group_name == group_name).get()
if len(Mute.select().where(Mute.group == self._group, Mute.user == chat_handler.user)) == 0:
show_keyboard = {'keyboard': [['60','1440'],['2160','10080']]}
self.current_handler = self.handle_time
yield from chat_handler.sender.sendMessage(_s["msg_howlongmute"], reply_markup=show_keyboard)
else:
self.cancel()
yield from chat_handler.sender.sendMessage("You are already muting this group",reply_markup={'hide_keyboard': True})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg,chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name==group_name)) > 0 :
self._group = Group.select().where(Group.group_name == group_name).get()
if chat_handler.user.auth_level > 2:
self.current_handler = self.handle_message
yield from chat_handler.sender.sendMessage(_s["msg_pingmessageq"],reply_markup={'hide_keyboard': True})
elif len(GroupMembership.select().where(GroupMembership.group == self._group, GroupMembership.user == chat_handler.user)) > 0:
self.current_handler = self.handle_message
yield from chat_handler.sender.sendMessage(_s["msg_pingmessageq"],reply_markup={'hide_keyboard': True})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
corps = [c.corporation_name for c in Character.select()]
corp_count = [t[0] for t in Counter(corps).most_common(10)]
options = [corp_count[:5], corp_count[5:]]
self._group = Group.select().where(
Group.group_name == group_name).get()
self.current_handler = self.handle_corp
yield from chat_handler.sender.sendMessage(
_s["msg_whichingamecorp"],
reply_markup={'keyboard': options})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
self._group = Group.select().where(
Group.group_name == group_name).get()
mute_instance = Mute.select().where(
Mute.user == chat_handler.user,
Mute.group == self._group).get()
mute_instance.delete_instance()
self.finished()
yield from chat_handler.sender.sendMessage(
_s["msg_groupunmuted"],
reply_markup={'hide_keyboard': True})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
alliances = [c.alliance_name for c in Character.select()]
alliances_count = [
t[0] for t in Counter(alliances).most_common(10)
if t[0] != ""
]
options = [alliances_count[:5], alliances_count[5:]]
self._group = Group.select().where(
Group.group_name == group_name).get()
self.current_handler = self.handle_alliance
yield from chat_handler.sender.sendMessage(
_s["msg_whichingamealliance"],
reply_markup={'keyboard': options})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
async def initial_handler(self, msg, chat_handler):
if len(Group.select().where(Group.group_name == get_config_item("OPS_GROUP", "ncdot"))) > 0:
ncdotgroup = Group.select().where(Group.group_name == get_config_item("OPS_GROUP", "ncdot")).get()
if len(GroupMembership.select().where(GroupMembership.group == ncdotgroup, GroupMembership.user == chat_handler.user))> 0:
try:
r = await aiohttp.get(get_config_item("OPS_JSON_URL", 'ncdotopsurl'))
self._ops = (await r.json())["ops"]
self.finished()
if self._ops != []:
await self.send_template(chat_handler, "OPS")
else:
await chat_handler.sender.sendMessage("No ops planned")
except:
traceback.print_exc()
self.finished()
await chat_handler.sender.sendMessage("error getting !ops")
else:
self.finished()
await chat_handler.sender.sendMessage("you are not in ncdot group")
else:
self.finished()
await chat_handler.sender.sendMessage("no ncdot group")
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
self._group = Group.select().where(
Group.group_name == group_name).get()
if chat_handler.user.auth_level > 2:
self.current_handler = self.handle_message
yield from chat_handler.sender.sendMessage(
_s["msg_pingmessageq"],
reply_markup={'hide_keyboard': True})
elif len(GroupMembership.select().where(
GroupMembership.group == self._group,
GroupMembership.user == chat_handler.user)) > 0:
self.current_handler = self.handle_message
yield from chat_handler.sender.sendMessage(
_s["msg_pingmessageq"],
reply_markup={'hide_keyboard': True})
else:
yield from chat_handler.sender.sendMessage(
_s["msg_notagroup"])
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
def handle_group(self, msg, chat_handler):
if (yield from assert_text(msg, chat_handler)):
group_name = msg["text"]
if len(Group.select().where(Group.group_name == group_name)) > 0:
self._group = Group.select().where(
Group.group_name == group_name).get()
if len(Mute.select().where(
Mute.group == self._group,
Mute.user == chat_handler.user)) == 0:
show_keyboard = {
'keyboard': [['60', '1440'], ['2160', '10080']]
}
self.current_handler = self.handle_time
yield from chat_handler.sender.sendMessage(
_s["msg_howlongmute"], reply_markup=show_keyboard)
else:
self.cancel()
yield from chat_handler.sender.sendMessage(
"You are already muting this group",
reply_markup={'hide_keyboard': True})
else:
yield from chat_handler.sender.sendMessage(_s["msg_notagroup"])
async def auto_group_char(user, character):
try:
player_name = user.display_name()
# find all group links for this character
char_links = [
set(link.group.group_name for link in GroupLink.select().where(
GroupLink.character_field_name == field_name,
GroupLink.field_value == getattr(character, field_name)))
for field_name in Character._meta.fields.keys()
]
flat_links = set.union(*char_links)
for linked_group_name in flat_links:
linked_group = Group.select().where(
Group.group_name == linked_group_name).get()
add = True
link_fields = {
link.character_field_name: False
for link in GroupLink.select().where(
GroupLink.group == linked_group)
}
# make sure this character satisfies every link for this group
for link in GroupLink.select().where(
GroupLink.group == linked_group):
if getattr(character,
link.character_field_name) == link.field_value:
link_fields[link.character_field_name] = True
for lf in link_fields:
add = add and link_fields[lf]
approved = linked_group.auto_approval
if len(GroupApproval.select().where(
GroupApproval.user == user, GroupApproval.group
== linked_group)) > 0:
approved = True
if add and approved:
GroupMembership.create_or_get(user=user, group=linked_group)
logging.warning("Added " + player_name + " to " +
linked_group.group_name)
except:
traceback.print_exc()
async def auto_group_char(user, character):
try:
player_name = user.display_name()
# find all group links for this character
char_links = [
set(link.group.group_name for link in GroupLink.select().where(
GroupLink.character_field_name == field_name,
GroupLink.field_value == getattr(character, field_name))
)
for field_name in Character._meta.fields.keys()
]
flat_links = set.union(*char_links)
for linked_group_name in flat_links:
linked_group = Group.select().where(Group.group_name == linked_group_name).get()
add = True
link_fields = {link.character_field_name: False for link in
GroupLink.select().where(GroupLink.group == linked_group)}
# make sure this character satisfies every link for this group
for link in GroupLink.select().where(GroupLink.group == linked_group):
if getattr(character, link.character_field_name) == link.field_value:
link_fields[link.character_field_name] = True
for lf in link_fields:
add = add and link_fields[lf]
approved = linked_group.auto_approval
if len(GroupApproval.select().where(
GroupApproval.user == user,
GroupApproval.group == linked_group)) > 0:
approved = True
if add and approved:
GroupMembership.create_or_get(
user=user,
group=linked_group
)
logging.warning("Added " + player_name + " to " + linked_group.group_name)
except:
traceback.print_exc()
async def legacy_parse(request):
global last_message, last_message_time
data = await request.post()
raw = data["messages"]
#remove irc formatting
pattern = r'[\x02\x0F\x16\x1D\x1F]|\x03(\d{,2}(,\d{,2})?)?'
raw = re.sub(pattern, '', raw)
if raw[-2:] == ",]":
raw = raw[:-2] + "]"
parsed = []
try:
parsed = json.loads(raw)
except Exception:
e = sys.exc_info()[0]
print(e)
traceback.print_exc()
print(raw)
r = re.compile(
get_config_item("IRSSI_PING_FORMAT",
"\[BROADCAST/([\w\s;]*)]\s(\w*)\:\s(.*)"))
msg = ""
for pingrow in parsed:
#ping_time = pingrow["time"]
#sender = pingrow["sender"]
message = pingrow["message"]
m = r.search(message)
legacy_groups = m.groups()[0].split(";")
legacy_sender = m.groups()[1]
message = m.groups()[2]
if pingrow[
"message"] != last_message or last_message_time + datetime.timedelta(
minutes=30) < datetime.datetime.now():
last_message = pingrow["message"]
last_message_time = datetime.datetime.now()
for group in legacy_groups:
group_name = group.lower().strip()
tasks = []
success = 0
# look up the group, for each user id send the 'message'
for member in GroupMembership.select().where(
GroupMembership.group == Group.select().where(
Group.legacy_name == group_name)):
tasks.append(
safe_send(
member.user.telegram_id,
"Ping from " + legacy_sender + " to " +
group_name + ":\n\n" + message))
success += 1
def chunks(l, n):
for i in range(0, len(l), n):
yield l[i:i + n]
start_time = time.time()
for chunk in chunks(tasks,
get_config_item("THROTTLE_CHUNK_SIZE",
20)):
await asyncio.gather(*chunk)
await asyncio.sleep(1)
elapsed = time.time() - start_time
rounded = math.floor(elapsed * 100) / 100
msg += "Ping sent to " + str(
success) + " users for " + group_name + " in " + str(
rounded) + " seconds\n"
print(msg)
return web.Response(body=msg.encode('utf-8'))
async def legacy_parse(request):
global last_message, last_message_time
data = await request.post()
raw = data["messages"]
#remove irc formatting
pattern = r'[\x02\x0F\x16\x1D\x1F]|\x03(\d{,2}(,\d{,2})?)?'
raw = re.sub(pattern, '', raw)
if raw[-2:] == ",]":
raw = raw[:-2]+"]"
parsed = []
try:
parsed = json.loads(raw)
except Exception:
e = sys.exc_info()[0]
print(e)
traceback.print_exc()
print(raw)
r = re.compile(get_config_item("IRSSI_PING_FORMAT", "\[BROADCAST/([\w\s;]*)]\s(\w*)\:\s(.*)"))
msg = ""
for pingrow in parsed:
#ping_time = pingrow["time"]
#sender = pingrow["sender"]
message = pingrow["message"]
m = r.search(message)
legacy_groups = m.groups()[0].split(";")
legacy_sender = m.groups()[1]
message = m.groups()[2]
if pingrow["message"] != last_message or last_message_time + datetime.timedelta(minutes=30) < datetime.datetime.now():
last_message = pingrow["message"]
last_message_time = datetime.datetime.now()
for group in legacy_groups:
group_name = group.lower().strip()
tasks = []
success = 0
# look up the group, for each user id send the 'message'
for member in GroupMembership.select().where(GroupMembership.group==Group.select().where(Group.legacy_name == group_name)):
tasks.append(safe_send(member.user.telegram_id, "Ping from "+legacy_sender+" to "+group_name+":\n\n"+message))
success += 1
def chunks(l, n):
for i in range(0, len(l), n):
yield l[i:i+n]
start_time = time.time()
for chunk in chunks(tasks, get_config_item("THROTTLE_CHUNK_SIZE", 20)):
await asyncio.gather(*chunk)
await asyncio.sleep(1)
elapsed = time.time() - start_time
rounded = math.floor(elapsed*100)/100
msg += "Ping sent to "+str(success)+" users for "+group_name+" in "+str(rounded)+" seconds\n"
print(msg)
return web.Response(body=msg.encode('utf-8'))
